00109950 <_API_Mutex_Allocate>: #include void _API_Mutex_Allocate( API_Mutex_Control **the_mutex ) { 109950: 55 push %ebp <== NOT EXECUTED 109951: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109953: 57 push %edi <== NOT EXECUTED 109954: 56 push %esi <== NOT EXECUTED 109955: 53 push %ebx <== NOT EXECUTED 109956: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED CORE_mutex_Attributes attr = { CORE_MUTEX_NESTING_IS_ERROR, FALSE, CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT, 0 }; 109959: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 10995c: be 48 68 11 00 mov $0x116848,%esi <== NOT EXECUTED 109961: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 109966: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED mutex = (API_Mutex_Control *) _Objects_Allocate( &_API_Mutex_Information ); 109968: 68 ec ca 11 00 push $0x11caec <== NOT EXECUTED 10996d: e8 4a 08 00 00 call 10a1bc <_Objects_Allocate> <== NOT EXECUTED 109972: 89 c3 mov %eax,%ebx <== NOT EXECUTED _CORE_mutex_Initialize( &mutex->Mutex, &attr, CORE_MUTEX_UNLOCKED ); 109974: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 109977: 6a 01 push $0x1 <== NOT EXECUTED 109979: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10997c: 50 push %eax <== NOT EXECUTED 10997d: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 109980: 50 push %eax <== NOT EXECUTED 109981: e8 f6 01 00 00 call 109b7c <_CORE_mutex_Initialize> <== NOT EXECUTED 109986: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 10998a: a1 08 cb 11 00 mov 0x11cb08,%eax <== NOT EXECUTED 10998f: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 109992: c7 43 0c 01 00 00 00 movl $0x1,0xc(%ebx) <== NOT EXECUTED _Objects_Open_u32( &_API_Mutex_Information, &mutex->Object, 1 ); *the_mutex = mutex; 109999: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10999c: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10999e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1099a1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1099a4: 5b pop %ebx <== NOT EXECUTED 1099a5: 5e pop %esi <== NOT EXECUTED 1099a6: 5f pop %edi <== NOT EXECUTED 1099a7: c9 leave <== NOT EXECUTED 1099a8: c3 ret <== NOT EXECUTED 001099d0 <_API_Mutex_Initialization>: #include void _API_Mutex_Initialization( uint32_t maximum_mutexes ) { 1099d0: 55 push %ebp <== NOT EXECUTED 1099d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099d3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 1099d6: 6a 00 push $0x0 <== NOT EXECUTED 1099d8: 6a 00 push $0x0 <== NOT EXECUTED 1099da: 6a 74 push $0x74 <== NOT EXECUTED 1099dc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1099df: 6a 02 push $0x2 <== NOT EXECUTED 1099e1: 6a 01 push $0x1 <== NOT EXECUTED 1099e3: 68 ec ca 11 00 push $0x11caec <== NOT EXECUTED 1099e8: e8 6b 0c 00 00 call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 1099ed: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , TRUE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 1099f0: c9 leave <== NOT EXECUTED 1099f1: c3 ret <== NOT EXECUTED 001099ac <_API_Mutex_Lock>: #include void _API_Mutex_Lock( API_Mutex_Control *the_mutex ) { 1099ac: 55 push %ebp <== NOT EXECUTED 1099ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099af: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 1099b2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 1099b5: 9c pushf <== NOT EXECUTED 1099b6: fa cli <== NOT EXECUTED 1099b7: 5a pop %edx <== NOT EXECUTED _CORE_mutex_Seize( 1099b8: 52 push %edx <== NOT EXECUTED 1099b9: 6a 00 push $0x0 <== NOT EXECUTED 1099bb: 6a 01 push $0x1 <== NOT EXECUTED 1099bd: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1099c0: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 1099c3: 50 push %eax <== NOT EXECUTED 1099c4: e8 9f 02 00 00 call 109c68 <_CORE_mutex_Seize> <== NOT EXECUTED 1099c9: 83 c4 20 add $0x20,%esp <== NOT EXECUTED the_mutex->Object.id, TRUE, 0, level ); } 1099cc: c9 leave <== NOT EXECUTED 1099cd: c3 ret <== NOT EXECUTED 001099f4 <_API_Mutex_Unlock>: #include void _API_Mutex_Unlock( API_Mutex_Control *the_mutex ) { 1099f4: 55 push %ebp <== NOT EXECUTED 1099f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099f7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1099fa: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1099fd: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 109a02: 40 inc %eax <== NOT EXECUTED 109a03: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED _Thread_Disable_dispatch(); _CORE_mutex_Surrender( 109a08: 6a 00 push $0x0 <== NOT EXECUTED 109a0a: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED 109a0d: 83 c2 10 add $0x10,%edx <== NOT EXECUTED 109a10: 52 push %edx <== NOT EXECUTED 109a11: e8 e2 02 00 00 call 109cf8 <_CORE_mutex_Surrender> <== NOT EXECUTED &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 109a16: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109a19: c9 leave <== NOT EXECUTED _CORE_mutex_Surrender( &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 109a1a: e9 a1 13 00 00 jmp 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 00109936 <_API_extensions_Add>: */ void _API_extensions_Add( API_extensions_Control *the_extension ) { 109936: 55 push %ebp <== NOT EXECUTED 109937: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109939: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED _Chain_Append( &_API_extensions_List, &the_extension->Node ); 10993c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10993f: 68 24 cc 11 00 push $0x11cc24 <== NOT EXECUTED 109944: e8 d7 00 00 00 call 109a20 <_Chain_Append> <== NOT EXECUTED 109949: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10994c: c9 leave <== NOT EXECUTED 10994d: c3 ret <== NOT EXECUTED 00109894 <_API_extensions_Initialization>: * * _API_extensions_Initialization */ void _API_extensions_Initialization( void ) { 109894: 55 push %ebp <== NOT EXECUTED 109895: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109897: c7 05 24 cc 11 00 28 movl $0x11cc28,0x11cc24 <== NOT EXECUTED 10989e: cc 11 00 <== NOT EXECUTED 1098a1: c7 05 28 cc 11 00 00 movl $0x0,0x11cc28 <== NOT EXECUTED 1098a8: 00 00 00 <== NOT EXECUTED 1098ab: c7 05 2c cc 11 00 24 movl $0x11cc24,0x11cc2c <== NOT EXECUTED 1098b2: cc 11 00 <== NOT EXECUTED _Chain_Initialize_empty( &_API_extensions_List ); } 1098b5: c9 leave <== NOT EXECUTED 1098b6: c3 ret <== NOT EXECUTED 001098dd <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 1098dd: 55 push %ebp <== NOT EXECUTED 1098de: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1098e0: 53 push %ebx <== NOT EXECUTED 1098e1: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 1098e4: 8b 1d 24 cc 11 00 mov 0x11cc24,%ebx <== NOT EXECUTED 1098ea: eb 0b jmp 1098f7 <_API_extensions_Run_postdriver+0x1a> <== NOT EXECUTED !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) 1098ec: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 1098ef: 85 c0 test %eax,%eax <== NOT EXECUTED 1098f1: 74 02 je 1098f5 <_API_extensions_Run_postdriver+0x18> <== NOT EXECUTED (*the_extension->postdriver_hook)(); 1098f3: ff d0 call *%eax <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { 1098f5: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 1098f7: 81 fb 28 cc 11 00 cmp $0x11cc28,%ebx <== NOT EXECUTED 1098fd: 75 ed jne 1098ec <_API_extensions_Run_postdriver+0xf> <== NOT EXECUTED the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) (*the_extension->postdriver_hook)(); } } 1098ff: 5a pop %edx <== NOT EXECUTED 109900: 5b pop %ebx <== NOT EXECUTED 109901: c9 leave <== NOT EXECUTED 109902: c3 ret <== NOT EXECUTED 00109903 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 109903: 55 push %ebp <== NOT EXECUTED 109904: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109906: 53 push %ebx <== NOT EXECUTED 109907: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10990a: 8b 1d 24 cc 11 00 mov 0x11cc24,%ebx <== NOT EXECUTED 109910: eb 17 jmp 109929 <_API_extensions_Run_postswitch+0x26> <== NOT EXECUTED !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) 109912: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 109915: 85 c0 test %eax,%eax <== NOT EXECUTED 109917: 74 0e je 109927 <_API_extensions_Run_postswitch+0x24> <== NOT EXECUTED (*the_extension->postswitch_hook)( _Thread_Executing ); 109919: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10991c: ff 35 c0 ca 11 00 pushl 0x11cac0 <== NOT EXECUTED 109922: ff d0 call *%eax <== NOT EXECUTED 109924: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { 109927: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 109929: 81 fb 28 cc 11 00 cmp $0x11cc28,%ebx <== NOT EXECUTED 10992f: 75 e1 jne 109912 <_API_extensions_Run_postswitch+0xf> <== NOT EXECUTED the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) (*the_extension->postswitch_hook)( _Thread_Executing ); } } 109931: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109934: c9 leave <== NOT EXECUTED 109935: c3 ret <== NOT EXECUTED 001098b7 <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 1098b7: 55 push %ebp <== NOT EXECUTED 1098b8: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1098ba: 53 push %ebx <== NOT EXECUTED 1098bb: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 1098be: 8b 1d 24 cc 11 00 mov 0x11cc24,%ebx <== NOT EXECUTED 1098c4: eb 0b jmp 1098d1 <_API_extensions_Run_predriver+0x1a> <== NOT EXECUTED !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) 1098c6: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 1098c9: 85 c0 test %eax,%eax <== NOT EXECUTED 1098cb: 74 02 je 1098cf <_API_extensions_Run_predriver+0x18> <== NOT EXECUTED (*the_extension->predriver_hook)(); 1098cd: ff d0 call *%eax <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { 1098cf: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 1098d1: 81 fb 28 cc 11 00 cmp $0x11cc28,%ebx <== NOT EXECUTED 1098d7: 75 ed jne 1098c6 <_API_extensions_Run_predriver+0xf> <== NOT EXECUTED the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) (*the_extension->predriver_hook)(); } } 1098d9: 58 pop %eax <== NOT EXECUTED 1098da: 5b pop %ebx <== NOT EXECUTED 1098db: c9 leave <== NOT EXECUTED 1098dc: c3 ret <== NOT EXECUTED 0010d248 <_Barrier_Manager_initialization>: */ void _Barrier_Manager_initialization( uint32_t maximum_barriers ) { 10d248: 55 push %ebp <== NOT EXECUTED 10d249: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d24b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d24e: 6a 04 push $0x4 <== NOT EXECUTED 10d250: 6a 00 push $0x0 <== NOT EXECUTED 10d252: 6a 60 push $0x60 <== NOT EXECUTED 10d254: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d257: 6a 0a push $0xa <== NOT EXECUTED 10d259: 6a 02 push $0x2 <== NOT EXECUTED 10d25b: 68 34 cd 11 00 push $0x11cd34 <== NOT EXECUTED 10d260: e8 f3 d3 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 10d265: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10d268: c9 leave <== NOT EXECUTED 10d269: c3 ret <== NOT EXECUTED 0010e194 <_Barrier_Translate_core_barrier_return_code>: }; rtems_status_code _Barrier_Translate_core_barrier_return_code ( CORE_barrier_Status the_barrier_status ) { 10e194: 55 push %ebp <== NOT EXECUTED 10e195: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e197: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10e19a: 8b 04 85 d0 d3 11 00 mov 0x11d3d0(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_barrier_status > CORE_BARRIER_STATUS_LAST ) return RTEMS_INTERNAL_ERROR; #endif return _Barrier_Translate_core_barrier_return_code_[the_barrier_status]; } 10e1a1: c9 leave <== NOT EXECUTED 10e1a2: c3 ret <== NOT EXECUTED 0010a834 <_CORE_barrier_Initialize>: void _CORE_barrier_Initialize( CORE_barrier_Control *the_barrier, CORE_barrier_Attributes *the_barrier_attributes ) { 10a834: 55 push %ebp <== NOT EXECUTED 10a835: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a837: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a83a: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a83d: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED the_barrier->Attributes = *the_barrier_attributes; 10a840: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10a842: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10a845: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED 10a848: 89 4a 40 mov %ecx,0x40(%edx) <== NOT EXECUTED the_barrier->number_of_waiting_threads = 0; 10a84b: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) <== NOT EXECUTED _Thread_queue_Initialize( 10a852: 6a 03 push $0x3 <== NOT EXECUTED 10a854: 68 00 00 01 00 push $0x10000 <== NOT EXECUTED 10a859: 6a 00 push $0x0 <== NOT EXECUTED 10a85b: 52 push %edx <== NOT EXECUTED 10a85c: e8 8f 1a 00 00 call 10c2f0 <_Thread_queue_Initialize> <== NOT EXECUTED 10a861: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &the_barrier->Wait_queue, THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_BARRIER, CORE_BARRIER_TIMEOUT ); } 10a864: c9 leave <== NOT EXECUTED 10a865: c3 ret <== NOT EXECUTED 0010a868 <_CORE_barrier_Release>: uint32_t _CORE_barrier_Release( CORE_barrier_Control *the_barrier, Objects_Id id, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 10a868: 55 push %ebp <== NOT EXECUTED 10a869: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a86b: 56 push %esi <== NOT EXECUTED 10a86c: 53 push %ebx <== NOT EXECUTED 10a86d: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Thread_Control *the_thread; uint32_t count; count = 0; while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) { 10a870: 31 db xor %ebx,%ebx <== NOT EXECUTED 10a872: eb 01 jmp 10a875 <_CORE_barrier_Release+0xd> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_barrier_mp_support) ( the_thread, id ); #endif count++; 10a874: 43 inc %ebx <== NOT EXECUTED { Thread_Control *the_thread; uint32_t count; count = 0; while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) { 10a875: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a878: 56 push %esi <== NOT EXECUTED 10a879: e8 26 17 00 00 call 10bfa4 <_Thread_queue_Dequeue> <== NOT EXECUTED 10a87e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a881: 85 c0 test %eax,%eax <== NOT EXECUTED 10a883: 75 ef jne 10a874 <_CORE_barrier_Release+0xc> <== NOT EXECUTED if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_barrier_mp_support) ( the_thread, id ); #endif count++; } the_barrier->number_of_waiting_threads = 0; 10a885: c7 46 48 00 00 00 00 movl $0x0,0x48(%esi) <== NOT EXECUTED return count; } 10a88c: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a88e: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a891: 5b pop %ebx <== NOT EXECUTED 10a892: 5e pop %esi <== NOT EXECUTED 10a893: c9 leave <== NOT EXECUTED 10a894: c3 ret <== NOT EXECUTED 0010a898 <_CORE_barrier_Wait>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 10a898: 55 push %ebp <== NOT EXECUTED 10a899: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a89b: 57 push %edi <== NOT EXECUTED 10a89c: 56 push %esi <== NOT EXECUTED 10a89d: 53 push %ebx <== NOT EXECUTED 10a89e: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a8a1: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a8a4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10a8a7: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a8aa: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 10a8ad: 8b 7d 18 mov 0x18(%ebp),%edi <== NOT EXECUTED Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 10a8b0: 8b 0d b4 f5 11 00 mov 0x11f5b4,%ecx <== NOT EXECUTED executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; 10a8b6: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) <== NOT EXECUTED _ISR_Disable( level ); 10a8bd: 9c pushf <== NOT EXECUTED 10a8be: fa cli <== NOT EXECUTED 10a8bf: 5b pop %ebx <== NOT EXECUTED the_barrier->number_of_waiting_threads++; 10a8c0: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED 10a8c3: 40 inc %eax <== NOT EXECUTED 10a8c4: 89 42 48 mov %eax,0x48(%edx) <== NOT EXECUTED if ( the_barrier->number_of_waiting_threads == 10a8c7: 3b 42 44 cmp 0x44(%edx),%eax <== NOT EXECUTED 10a8ca: 75 22 jne 10a8ee <_CORE_barrier_Wait+0x56> <== NOT EXECUTED the_barrier->Attributes.maximum_count) { if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { 10a8cc: 83 7a 40 00 cmpl $0x0,0x40(%edx) <== NOT EXECUTED 10a8d0: 75 1c jne 10a8ee <_CORE_barrier_Wait+0x56> <== NOT EXECUTED executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED; 10a8d2: c7 41 34 01 00 00 00 movl $0x1,0x34(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10a8d9: 53 push %ebx <== NOT EXECUTED 10a8da: 9d popf <== NOT EXECUTED _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support ); 10a8db: 89 7d 10 mov %edi,0x10(%ebp) <== NOT EXECUTED 10a8de: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10a8e1: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED executing->Wait.queue = &the_barrier->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); } 10a8e4: 5a pop %edx <== NOT EXECUTED 10a8e5: 5b pop %ebx <== NOT EXECUTED 10a8e6: 5e pop %esi <== NOT EXECUTED 10a8e7: 5f pop %edi <== NOT EXECUTED 10a8e8: c9 leave <== NOT EXECUTED if ( the_barrier->number_of_waiting_threads == the_barrier->Attributes.maximum_count) { if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED; _ISR_Enable( level ); _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support ); 10a8e9: e9 7a ff ff ff jmp 10a868 <_CORE_barrier_Release> <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10a8ee: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx) <== NOT EXECUTED return; } } _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue ); executing->Wait.queue = &the_barrier->Wait_queue; 10a8f5: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED executing->Wait.id = id; 10a8f8: 89 71 20 mov %esi,0x20(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10a8fb: 53 push %ebx <== NOT EXECUTED 10a8fc: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); 10a8fd: c7 45 10 c0 c3 10 00 movl $0x10c3c0,0x10(%ebp) <== NOT EXECUTED 10a904: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10a907: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10a90a: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10a90d: 58 pop %eax <== NOT EXECUTED 10a90e: 5b pop %ebx <== NOT EXECUTED 10a90f: 5e pop %esi <== NOT EXECUTED 10a910: 5f pop %edi <== NOT EXECUTED 10a911: c9 leave <== NOT EXECUTED _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue ); executing->Wait.queue = &the_barrier->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); 10a912: e9 a5 17 00 00 jmp 10c0bc <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 00113a3c <_CORE_message_queue_Broadcast>: size_t size, Objects_Id id, CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, uint32_t *count ) { 113a3c: 55 push %ebp <== NOT EXECUTED 113a3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113a3f: 57 push %edi <== NOT EXECUTED 113a40: 56 push %esi <== NOT EXECUTED 113a41: 53 push %ebx <== NOT EXECUTED 113a42: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 113a45: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 113a4a: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 113a4d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 113a50: 3b 4a 4c cmp 0x4c(%edx),%ecx <== NOT EXECUTED 113a53: 77 43 ja 113a98 <_CORE_message_queue_Broadcast+0x5c> <== NOT EXECUTED * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) { 113a55: 31 db xor %ebx,%ebx <== NOT EXECUTED * NOTE: This check is critical because threads can block on * send and receive and this ensures that we are broadcasting * the message to threads waiting to receive -- not to send. */ if ( the_message_queue->number_of_pending_messages != 0 ) { 113a57: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 113a5a: 83 7e 48 00 cmpl $0x0,0x48(%esi) <== NOT EXECUTED 113a5e: 74 21 je 113a81 <_CORE_message_queue_Broadcast+0x45> <== NOT EXECUTED *count = 0; 113a60: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 113a63: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 113a69: 31 c0 xor %eax,%eax <== NOT EXECUTED 113a6b: eb 2b jmp 113a98 <_CORE_message_queue_Broadcast+0x5c> <== NOT EXECUTED */ number_broadcasted = 0; while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) { waitp = &the_thread->Wait; number_broadcasted += 1; 113a6d: 43 inc %ebx <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 113a6e: 8b 78 2c mov 0x2c(%eax),%edi <== NOT EXECUTED 113a71: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 113a74: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 113a77: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 113a79: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 113a7c: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 113a7f: 89 10 mov %edx,(%eax) <== NOT EXECUTED * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) { 113a81: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113a84: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 113a87: e8 98 1f 00 00 call 115a24 <_Thread_queue_Dequeue> <== NOT EXECUTED 113a8c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113a8f: 85 c0 test %eax,%eax <== NOT EXECUTED 113a91: 75 da jne 113a6d <_CORE_message_queue_Broadcast+0x31> <== NOT EXECUTED if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_message_queue_mp_support) ( the_thread, id ); #endif } *count = number_broadcasted; 113a93: 8b 4d 1c mov 0x1c(%ebp),%ecx <== NOT EXECUTED 113a96: 89 19 mov %ebx,(%ecx) <== NOT EXECUTED return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 113a98: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 113a9b: 5b pop %ebx <== NOT EXECUTED 113a9c: 5e pop %esi <== NOT EXECUTED 113a9d: 5f pop %edi <== NOT EXECUTED 113a9e: c9 leave <== NOT EXECUTED 113a9f: c3 ret <== NOT EXECUTED 0011294c <_CORE_message_queue_Close>: void _CORE_message_queue_Close( CORE_message_queue_Control *the_message_queue, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 11294c: 55 push %ebp <== NOT EXECUTED 11294d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11294f: 53 push %ebx <== NOT EXECUTED 112950: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 112953: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* * This will flush blocked threads whether they were blocked on * a send or receive. */ _Thread_queue_Flush( 112956: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 112959: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11295c: 53 push %ebx <== NOT EXECUTED 11295d: e8 62 c1 ff ff call 10eac4 <_Thread_queue_Flush> <== NOT EXECUTED * This removes all messages from the pending message queue. Since * we just flushed all waiting threads, we don't have to worry about * the flush satisfying any blocked senders as a side-effect. */ if ( the_message_queue->number_of_pending_messages != 0 ) 112962: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112965: 83 7b 48 00 cmpl $0x0,0x48(%ebx) <== NOT EXECUTED 112969: 74 0c je 112977 <_CORE_message_queue_Close+0x2b> <== NOT EXECUTED (void) _CORE_message_queue_Flush_support( the_message_queue ); 11296b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11296e: 53 push %ebx <== NOT EXECUTED 11296f: e8 14 00 00 00 call 112988 <_CORE_message_queue_Flush_support> <== NOT EXECUTED 112974: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (void) _Workspace_Free( the_message_queue->message_buffers ); 112977: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED 11297a: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 11297d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112980: c9 leave <== NOT EXECUTED */ if ( the_message_queue->number_of_pending_messages != 0 ) (void) _CORE_message_queue_Flush_support( the_message_queue ); (void) _Workspace_Free( the_message_queue->message_buffers ); 112981: e9 f6 ca ff ff jmp 10f47c <_Workspace_Free> <== NOT EXECUTED 00113adc <_CORE_message_queue_Flush>: */ uint32_t _CORE_message_queue_Flush( CORE_message_queue_Control *the_message_queue ) { 113adc: 55 push %ebp <== NOT EXECUTED 113add: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113adf: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages != 0 ) 113ae2: 83 78 48 00 cmpl $0x0,0x48(%eax) <== NOT EXECUTED 113ae6: 75 04 jne 113aec <_CORE_message_queue_Flush+0x10> <== NOT EXECUTED return _CORE_message_queue_Flush_support( the_message_queue ); else return 0; } 113ae8: 31 c0 xor %eax,%eax <== NOT EXECUTED 113aea: c9 leave <== NOT EXECUTED 113aeb: c3 ret <== NOT EXECUTED uint32_t _CORE_message_queue_Flush( CORE_message_queue_Control *the_message_queue ) { if ( the_message_queue->number_of_pending_messages != 0 ) return _CORE_message_queue_Flush_support( the_message_queue ); 113aec: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED else return 0; } 113aef: c9 leave <== NOT EXECUTED uint32_t _CORE_message_queue_Flush( CORE_message_queue_Control *the_message_queue ) { if ( the_message_queue->number_of_pending_messages != 0 ) return _CORE_message_queue_Flush_support( the_message_queue ); 113af0: e9 03 00 00 00 jmp 113af8 <_CORE_message_queue_Flush_support> <== NOT EXECUTED 00112988 <_CORE_message_queue_Flush_support>: */ uint32_t _CORE_message_queue_Flush_support( CORE_message_queue_Control *the_message_queue ) { 112988: 55 push %ebp <== NOT EXECUTED 112989: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11298b: 56 push %esi <== NOT EXECUTED 11298c: 53 push %ebx <== NOT EXECUTED 11298d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED * * For now, though, we are very happy to have a small routine with * fixed execution time that only deals with pending messages. */ _ISR_Disable( level ); 112990: 9c pushf <== NOT EXECUTED 112991: fa cli <== NOT EXECUTED 112992: 5e pop %esi <== NOT EXECUTED inactive_first = the_message_queue->Inactive_messages.first; 112993: 8b 4a 68 mov 0x68(%edx),%ecx <== NOT EXECUTED message_queue_first = the_message_queue->Pending_messages.first; 112996: 8b 5a 50 mov 0x50(%edx),%ebx <== NOT EXECUTED message_queue_last = the_message_queue->Pending_messages.last; 112999: 8b 42 58 mov 0x58(%edx),%eax <== NOT EXECUTED the_message_queue->Inactive_messages.first = message_queue_first; 11299c: 89 5a 68 mov %ebx,0x68(%edx) <== NOT EXECUTED message_queue_last->next = inactive_first; 11299f: 89 08 mov %ecx,(%eax) <== NOT EXECUTED inactive_first->previous = message_queue_last; 1129a1: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED message_queue_first->previous = 1129a4: 8d 42 68 lea 0x68(%edx),%eax <== NOT EXECUTED 1129a7: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED 1129aa: 8d 42 54 lea 0x54(%edx),%eax <== NOT EXECUTED 1129ad: 89 42 50 mov %eax,0x50(%edx) <== NOT EXECUTED 1129b0: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) <== NOT EXECUTED 1129b7: 8d 42 50 lea 0x50(%edx),%eax <== NOT EXECUTED 1129ba: 89 42 58 mov %eax,0x58(%edx) <== NOT EXECUTED _Chain_Head( &the_message_queue->Inactive_messages ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); count = the_message_queue->number_of_pending_messages; 1129bd: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED the_message_queue->number_of_pending_messages = 0; 1129c0: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) <== NOT EXECUTED _ISR_Enable( level ); 1129c7: 56 push %esi <== NOT EXECUTED 1129c8: 9d popf <== NOT EXECUTED return count; } 1129c9: 5b pop %ebx <== NOT EXECUTED 1129ca: 5e pop %esi <== NOT EXECUTED 1129cb: c9 leave <== NOT EXECUTED 1129cc: c3 ret <== NOT EXECUTED 0010e21c <_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 ) { 10e21c: 55 push %ebp <== NOT EXECUTED 10e21d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e21f: 57 push %edi <== NOT EXECUTED 10e220: 56 push %esi <== NOT EXECUTED 10e221: 53 push %ebx <== NOT EXECUTED 10e222: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e225: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10e228: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10e22b: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED size_t message_buffering_required; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; 10e22e: 89 7b 44 mov %edi,0x44(%ebx) <== NOT EXECUTED the_message_queue->number_of_pending_messages = 0; 10e231: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) <== NOT EXECUTED the_message_queue->maximum_message_size = maximum_message_size; 10e238: 89 53 4c mov %edx,0x4c(%ebx) <== NOT EXECUTED 10e23b: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED 10e242: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) <== NOT EXECUTED * Round size up to multiple of a pointer for chain init and * check for overflow on adding overhead to each message. */ allocated_message_size = maximum_message_size; if (allocated_message_size & (sizeof(uint32_t) - 1)) { 10e249: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e24b: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 10e24e: 74 0a je 10e25a <_CORE_message_queue_Initialize+0x3e> <== NOT EXECUTED allocated_message_size += sizeof(uint32_t); 10e250: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED allocated_message_size &= ~(sizeof(uint32_t) - 1); 10e253: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED } if (allocated_message_size < maximum_message_size) 10e256: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10e258: 72 5f jb 10e2b9 <_CORE_message_queue_Initialize+0x9d> <== NOT EXECUTED /* * Calculate how much total memory is required for message buffering and * check for overflow on the multiplication. */ message_buffering_required = (size_t) maximum_pending_messages * 10e25a: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 10e25d: 89 f2 mov %esi,%edx <== NOT EXECUTED 10e25f: 0f af d7 imul %edi,%edx <== NOT EXECUTED (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 10e262: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10e264: 72 53 jb 10e2b9 <_CORE_message_queue_Initialize+0x9d> <== NOT EXECUTED return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 10e266: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e269: 52 push %edx <== NOT EXECUTED 10e26a: e8 6e 26 00 00 call 1108dd <_Workspace_Allocate> <== NOT EXECUTED 10e26f: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 10e272: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e275: 85 c0 test %eax,%eax <== NOT EXECUTED 10e277: 74 40 je 10e2b9 <_CORE_message_queue_Initialize+0x9d> <== NOT EXECUTED /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 10e279: 56 push %esi <== NOT EXECUTED 10e27a: 57 push %edi <== NOT EXECUTED 10e27b: 50 push %eax <== NOT EXECUTED 10e27c: 8d 43 68 lea 0x68(%ebx),%eax <== NOT EXECUTED 10e27f: 50 push %eax <== NOT EXECUTED 10e280: e8 7b 34 01 00 call 121700 <_Chain_Initialize> <== NOT EXECUTED 10e285: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10e288: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED 10e28b: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED 10e292: 8d 43 50 lea 0x50(%ebx),%eax <== NOT EXECUTED 10e295: 89 43 58 mov %eax,0x58(%ebx) <== NOT EXECUTED allocated_message_size + sizeof( CORE_message_queue_Buffer_control ) ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); _Thread_queue_Initialize( 10e298: 6a 06 push $0x6 <== NOT EXECUTED 10e29a: 68 80 00 00 00 push $0x80 <== NOT EXECUTED 10e29f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e2a2: 83 38 01 cmpl $0x1,(%eax) <== NOT EXECUTED 10e2a5: 0f 94 c0 sete %al <== NOT EXECUTED 10e2a8: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10e2ab: 50 push %eax <== NOT EXECUTED 10e2ac: 53 push %ebx <== NOT EXECUTED 10e2ad: e8 12 1d 00 00 call 10ffc4 <_Thread_queue_Initialize> <== NOT EXECUTED 10e2b2: b0 01 mov $0x1,%al <== NOT EXECUTED 10e2b4: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10e2b7: eb 02 jmp 10e2bb <_CORE_message_queue_Initialize+0x9f> <== NOT EXECUTED THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 10e2b9: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10e2bb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e2be: 5b pop %ebx <== NOT EXECUTED 10e2bf: 5e pop %esi <== NOT EXECUTED 10e2c0: 5f pop %edi <== NOT EXECUTED 10e2c1: c9 leave <== NOT EXECUTED 10e2c2: c3 ret <== NOT EXECUTED 0010d6a0 <_CORE_message_queue_Insert_message>: void _CORE_message_queue_Insert_message( CORE_message_queue_Control *the_message_queue, CORE_message_queue_Buffer_control *the_message, CORE_message_queue_Submit_types submit_type ) { 10d6a0: 55 push %ebp <== NOT EXECUTED 10d6a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d6a3: 57 push %edi <== NOT EXECUTED 10d6a4: 56 push %esi <== NOT EXECUTED 10d6a5: 53 push %ebx <== NOT EXECUTED 10d6a6: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d6a9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10d6ac: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10d6af: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED ISR_Level level; bool notify = false; the_message->priority = submit_type; 10d6b2: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED switch ( submit_type ) { 10d6b5: 3d 00 00 00 80 cmp $0x80000000,%eax <== NOT EXECUTED 10d6ba: 74 33 je 10d6ef <_CORE_message_queue_Insert_message+0x4f> <== NOT EXECUTED 10d6bc: 3d ff ff ff 7f cmp $0x7fffffff,%eax <== NOT EXECUTED 10d6c1: 8d 53 54 lea 0x54(%ebx),%edx <== NOT EXECUTED 10d6c4: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED 10d6c7: 75 4d jne 10d716 <_CORE_message_queue_Insert_message+0x76> <== NOT EXECUTED case CORE_MESSAGE_QUEUE_SEND_REQUEST: _ISR_Disable( level ); 10d6c9: 9c pushf <== NOT EXECUTED 10d6ca: fa cli <== NOT EXECUTED 10d6cb: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10d6cc: 8b 53 48 mov 0x48(%ebx),%edx <== NOT EXECUTED 10d6cf: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10d6d2: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 10d6d5: 85 d2 test %edx,%edx <== NOT EXECUTED 10d6d7: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED 10d6db: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10d6de: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10d6e0: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED 10d6e3: 89 73 58 mov %esi,0x58(%ebx) <== NOT EXECUTED 10d6e6: 89 30 mov %esi,(%eax) <== NOT EXECUTED 10d6e8: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED notify = true; _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 10d6eb: 51 push %ecx <== NOT EXECUTED 10d6ec: 9d popf <== NOT EXECUTED 10d6ed: eb 5b jmp 10d74a <_CORE_message_queue_Insert_message+0xaa> <== NOT EXECUTED break; case CORE_MESSAGE_QUEUE_URGENT_REQUEST: _ISR_Disable( level ); 10d6ef: 9c pushf <== NOT EXECUTED 10d6f0: fa cli <== NOT EXECUTED 10d6f1: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10d6f2: 8b 53 48 mov 0x48(%ebx),%edx <== NOT EXECUTED 10d6f5: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10d6f8: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 10d6fb: 85 d2 test %edx,%edx <== NOT EXECUTED 10d6fd: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED size_t size ); /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the 10d701: 8d 43 50 lea 0x50(%ebx),%eax <== NOT EXECUTED 10d704: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 10d707: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 10d70a: 89 73 50 mov %esi,0x50(%ebx) <== NOT EXECUTED 10d70d: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10d70f: 89 70 04 mov %esi,0x4(%eax) <== NOT EXECUTED notify = true; _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 10d712: 51 push %ecx <== NOT EXECUTED 10d713: 9d popf <== NOT EXECUTED 10d714: eb 34 jmp 10d74a <_CORE_message_queue_Insert_message+0xaa> <== NOT EXECUTED CORE_message_queue_Buffer_control *this_message; Chain_Node *the_node; Chain_Control *the_header; the_header = &the_message_queue->Pending_messages; the_node = the_header->first; 10d716: 8b 7b 50 mov 0x50(%ebx),%edi <== NOT EXECUTED 10d719: eb 07 jmp 10d722 <_CORE_message_queue_Insert_message+0x82> <== NOT EXECUTED while ( !_Chain_Is_tail( the_header, the_node ) ) { this_message = (CORE_message_queue_Buffer_control *) the_node; if ( this_message->priority <= the_message->priority ) { 10d71b: 39 47 08 cmp %eax,0x8(%edi) <== NOT EXECUTED 10d71e: 7f 07 jg 10d727 <_CORE_message_queue_Insert_message+0x87> <== NOT EXECUTED the_node = the_node->next; 10d720: 8b 3f mov (%edi),%edi <== NOT EXECUTED Chain_Node *the_node; Chain_Control *the_header; the_header = &the_message_queue->Pending_messages; the_node = the_header->first; while ( !_Chain_Is_tail( the_header, the_node ) ) { 10d722: 3b 7d ec cmp -0x14(%ebp),%edi <== NOT EXECUTED 10d725: 75 f4 jne 10d71b <_CORE_message_queue_Insert_message+0x7b> <== NOT EXECUTED continue; } break; } _ISR_Disable( level ); 10d727: 9c pushf <== NOT EXECUTED 10d728: fa cli <== NOT EXECUTED 10d729: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10d72a: 8b 53 48 mov 0x48(%ebx),%edx <== NOT EXECUTED 10d72d: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10d730: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 10d733: 85 d2 test %edx,%edx <== NOT EXECUTED 10d735: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED notify = true; _Chain_Insert_unprotected( the_node->previous, &the_message->Node ); 10d739: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 10d73c: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 10d73f: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10d741: 89 30 mov %esi,(%eax) <== NOT EXECUTED 10d743: 89 16 mov %edx,(%esi) <== NOT EXECUTED 10d745: 89 72 04 mov %esi,0x4(%edx) <== NOT EXECUTED _ISR_Enable( level ); 10d748: 51 push %ecx <== NOT EXECUTED 10d749: 9d popf <== NOT EXECUTED * According to POSIX, does this happen before or after the message * is actually enqueued. It is logical to think afterwards, because * the message is actually in the queue at this point. */ if ( notify && the_message_queue->notify_handler ) 10d74a: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10d74e: 74 15 je 10d765 <_CORE_message_queue_Insert_message+0xc5> <== NOT EXECUTED 10d750: 8b 4b 60 mov 0x60(%ebx),%ecx <== NOT EXECUTED 10d753: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10d755: 74 0e je 10d765 <_CORE_message_queue_Insert_message+0xc5> <== NOT EXECUTED (*the_message_queue->notify_handler)( the_message_queue->notify_argument ); 10d757: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED 10d75a: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10d75d: 5b pop %ebx <== NOT EXECUTED 10d75e: 5e pop %esi <== NOT EXECUTED 10d75f: 5b pop %ebx <== NOT EXECUTED 10d760: 5e pop %esi <== NOT EXECUTED 10d761: 5f pop %edi <== NOT EXECUTED 10d762: c9 leave <== NOT EXECUTED * is actually enqueued. It is logical to think afterwards, because * the message is actually in the queue at this point. */ if ( notify && the_message_queue->notify_handler ) (*the_message_queue->notify_handler)( the_message_queue->notify_argument ); 10d763: ff e1 jmp *%ecx <== NOT EXECUTED } 10d765: 58 pop %eax <== NOT EXECUTED 10d766: 5a pop %edx <== NOT EXECUTED 10d767: 5b pop %ebx <== NOT EXECUTED 10d768: 5e pop %esi <== NOT EXECUTED 10d769: 5f pop %edi <== NOT EXECUTED 10d76a: c9 leave <== NOT EXECUTED 10d76b: c3 ret <== NOT EXECUTED 00112a9c <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 112a9c: 55 push %ebp <== NOT EXECUTED 112a9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112a9f: 57 push %edi <== NOT EXECUTED 112aa0: 56 push %esi <== NOT EXECUTED 112aa1: 53 push %ebx <== NOT EXECUTED 112aa2: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 112aa5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 112aa8: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 112aab: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 112aae: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED 112ab1: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 112ab4: 89 7d e8 mov %edi,-0x18(%ebp) <== NOT EXECUTED 112ab7: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 112aba: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED 112abd: 8b 55 1c mov 0x1c(%ebp),%edx <== NOT EXECUTED 112ac0: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED 112ac3: 8a 45 18 mov 0x18(%ebp),%al <== NOT EXECUTED 112ac6: 88 45 e3 mov %al,-0x1d(%ebp) <== NOT EXECUTED ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *executing; Thread_Control *the_thread; executing = _Thread_Executing; 112ac9: 8b 35 44 89 12 00 mov 0x128944,%esi <== NOT EXECUTED executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 112acf: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) <== NOT EXECUTED _ISR_Disable( level ); 112ad6: 9c pushf <== NOT EXECUTED 112ad7: fa cli <== NOT EXECUTED 112ad8: 59 pop %ecx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 112ad9: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 112adc: 8b 5a 50 mov 0x50(%edx),%ebx <== NOT EXECUTED 112adf: 89 d0 mov %edx,%eax <== NOT EXECUTED 112ae1: 83 c0 54 add $0x54,%eax <== NOT EXECUTED 112ae4: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 112ae6: 0f 84 9e 00 00 00 je 112b8a <_CORE_message_queue_Seize+0xee> <== NOT EXECUTED 112aec: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 112aee: 8b 7d d0 mov -0x30(%ebp),%edi <== NOT EXECUTED 112af1: 89 57 50 mov %edx,0x50(%edi) <== NOT EXECUTED 112af4: 89 f8 mov %edi,%eax <== NOT EXECUTED 112af6: 83 c0 50 add $0x50,%eax <== NOT EXECUTED 112af9: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); if ( the_message != NULL ) { 112afc: 85 db test %ebx,%ebx <== NOT EXECUTED 112afe: 0f 84 86 00 00 00 je 112b8a <_CORE_message_queue_Seize+0xee> <== NOT EXECUTED the_message_queue->number_of_pending_messages -= 1; 112b04: ff 4f 48 decl 0x48(%edi) <== NOT EXECUTED _ISR_Enable( level ); 112b07: 51 push %ecx <== NOT EXECUTED 112b08: 9d popf <== NOT EXECUTED *size_p = the_message->Contents.size; 112b09: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 112b0c: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 112b0f: 89 02 mov %eax,(%edx) <== NOT EXECUTED _Thread_Executing->Wait.count = the_message->priority; 112b11: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 112b14: a1 44 89 12 00 mov 0x128944,%eax <== NOT EXECUTED 112b19: 89 50 24 mov %edx,0x24(%eax) <== NOT EXECUTED _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size_p); 112b1c: 8d 7b 10 lea 0x10(%ebx),%edi <== NOT EXECUTED 112b1f: 89 7d f0 mov %edi,-0x10(%ebp) <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 112b22: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 112b25: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 112b27: 8b 7d e8 mov -0x18(%ebp),%edi <== NOT EXECUTED 112b2a: 8b 75 f0 mov -0x10(%ebp),%esi <== NOT EXECUTED 112b2d: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED * * NOTE: If we note that the queue was not full before this receive, * then we can avoid this dequeue. */ the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 112b2f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112b32: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED 112b35: e8 66 bc ff ff call 10e7a0 <_Thread_queue_Dequeue> <== NOT EXECUTED 112b3a: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !the_thread ) { 112b3c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112b3f: 85 c0 test %eax,%eax <== NOT EXECUTED 112b41: 75 18 jne 112b5b <_CORE_message_queue_Seize+0xbf> <== NOT EXECUTED * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size 112b43: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 112b46: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 112b49: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 112b4c: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 112b4f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112b52: 5b pop %ebx <== NOT EXECUTED 112b53: 5e pop %esi <== NOT EXECUTED 112b54: 5f pop %edi <== NOT EXECUTED 112b55: c9 leave <== NOT EXECUTED 112b56: e9 41 a5 ff ff jmp 10d09c <_Chain_Append> <== NOT EXECUTED * There was a thread waiting to send a message. This code * puts the messages in the message queue on behalf of the * waiting task. */ the_message->priority = the_thread->Wait.count; 112b5b: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED 112b5e: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED the_message->Contents.size = (size_t) the_thread->Wait.option; 112b61: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED 112b64: 89 4b 0c mov %ecx,0xc(%ebx) <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 112b67: 8b 72 2c mov 0x2c(%edx),%esi <== NOT EXECUTED 112b6a: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 112b6d: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED the_thread->Wait.return_argument_second.immutable_object, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 112b6f: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 112b72: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 112b75: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 112b78: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 112b7b: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 112b7e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112b81: 5b pop %ebx <== NOT EXECUTED 112b82: 5e pop %esi <== NOT EXECUTED 112b83: 5f pop %edi <== NOT EXECUTED 112b84: c9 leave <== NOT EXECUTED the_thread->Wait.return_argument_second.immutable_object, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 112b85: e9 46 fe ff ff jmp 1129d0 <_CORE_message_queue_Insert_message> <== NOT EXECUTED the_message->priority ); return; } if ( !wait ) { 112b8a: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) <== NOT EXECUTED 112b8e: 75 11 jne 112ba1 <_CORE_message_queue_Seize+0x105> <== NOT EXECUTED _ISR_Enable( level ); 112b90: 51 push %ecx <== NOT EXECUTED 112b91: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 112b92: c7 46 34 04 00 00 00 movl $0x4,0x34(%esi) <== NOT EXECUTED executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 112b99: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112b9c: 5b pop %ebx <== NOT EXECUTED 112b9d: 5e pop %esi <== NOT EXECUTED 112b9e: 5f pop %edi <== NOT EXECUTED 112b9f: c9 leave <== NOT EXECUTED 112ba0: c3 ret <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 112ba1: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 112ba4: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx) <== NOT EXECUTED executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; return; } _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; 112bab: 89 56 44 mov %edx,0x44(%esi) <== NOT EXECUTED executing->Wait.id = id; 112bae: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 112bb1: 89 7e 20 mov %edi,0x20(%esi) <== NOT EXECUTED executing->Wait.return_argument_second.mutable_object = buffer; 112bb4: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 112bb7: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED executing->Wait.return_argument = size_p; 112bba: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 112bbd: 89 56 28 mov %edx,0x28(%esi) <== NOT EXECUTED /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 112bc0: 51 push %ecx <== NOT EXECUTED 112bc1: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 112bc2: c7 45 10 bc eb 10 00 movl $0x10ebbc,0x10(%ebp) <== NOT EXECUTED 112bc9: 8b 7d dc mov -0x24(%ebp),%edi <== NOT EXECUTED 112bcc: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED 112bcf: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 112bd2: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 112bd5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112bd8: 5b pop %ebx <== NOT EXECUTED 112bd9: 5e pop %esi <== NOT EXECUTED 112bda: 5f pop %edi <== NOT EXECUTED 112bdb: c9 leave <== NOT EXECUTED executing->Wait.return_argument_second.mutable_object = buffer; executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 112bdc: e9 d7 bc ff ff jmp 10e8b8 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 00109a6c <_CORE_message_queue_Submit>: CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, CORE_message_queue_Submit_types submit_type, bool wait, Watchdog_Interval timeout ) { 109a6c: 55 push %ebp <== NOT EXECUTED 109a6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a6f: 57 push %edi <== NOT EXECUTED 109a70: 56 push %esi <== NOT EXECUTED 109a71: 53 push %ebx <== NOT EXECUTED 109a72: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 109a75: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 109a78: 8a 45 20 mov 0x20(%ebp),%al <== NOT EXECUTED 109a7b: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 109a7e: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 109a83: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 109a86: 3b 5a 4c cmp 0x4c(%edx),%ebx <== NOT EXECUTED 109a89: 0f 87 d9 00 00 00 ja 109b68 <_CORE_message_queue_Submit+0xfc> <== NOT EXECUTED /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { 109a8f: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 109a92: 83 7e 48 00 cmpl $0x0,0x48(%esi) <== NOT EXECUTED 109a96: 75 2e jne 109ac6 <_CORE_message_queue_Submit+0x5a> <== NOT EXECUTED the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 109a98: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109a9b: 56 push %esi <== NOT EXECUTED 109a9c: e8 57 16 00 00 call 10b0f8 <_Thread_queue_Dequeue> <== NOT EXECUTED 109aa1: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( the_thread ) { 109aa3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109aa6: 85 c0 test %eax,%eax <== NOT EXECUTED 109aa8: 74 1c je 109ac6 <_CORE_message_queue_Submit+0x5a> <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 109aaa: 8b 78 2c mov 0x2c(%eax),%edi <== NOT EXECUTED 109aad: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 109ab0: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 109ab2: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED _CORE_message_queue_Copy_buffer( buffer, the_thread->Wait.return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 109ab4: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 109ab7: 89 18 mov %ebx,(%eax) <== NOT EXECUTED the_thread->Wait.count = submit_type; 109ab9: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 109abc: 89 42 24 mov %eax,0x24(%edx) <== NOT EXECUTED 109abf: 31 c0 xor %eax,%eax <== NOT EXECUTED 109ac1: e9 a2 00 00 00 jmp 109b68 <_CORE_message_queue_Submit+0xfc> <== NOT EXECUTED /* * No one waiting on the message queue at this time, so attempt to * queue the message up for a future receive. */ if ( the_message_queue->number_of_pending_messages < 109ac6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 109ac9: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED 109acc: 3b 42 44 cmp 0x44(%edx),%eax <== NOT EXECUTED 109acf: 73 37 jae 109b08 <_CORE_message_queue_Submit+0x9c> <== NOT EXECUTED ); /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. 109ad1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109ad4: 89 d0 mov %edx,%eax <== NOT EXECUTED 109ad6: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 109ad9: 50 push %eax <== NOT EXECUTED 109ada: e8 65 ff ff ff call 109a44 <_Chain_Get> <== NOT EXECUTED /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 109adf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109ae2: 85 c0 test %eax,%eax <== NOT EXECUTED 109ae4: 74 7d je 109b63 <_CORE_message_queue_Submit+0xf7> <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 109ae6: 8d 78 10 lea 0x10(%eax),%edi <== NOT EXECUTED 109ae9: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 109aec: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 109aee: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, size ); the_message->Contents.size = size; 109af0: 89 58 0c mov %ebx,0xc(%eax) <== NOT EXECUTED the_message->priority = submit_type; 109af3: 8b 55 1c mov 0x1c(%ebp),%edx <== NOT EXECUTED 109af6: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED _CORE_message_queue_Insert_message( 109af9: 51 push %ecx <== NOT EXECUTED 109afa: 52 push %edx <== NOT EXECUTED 109afb: 50 push %eax <== NOT EXECUTED 109afc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109aff: e8 9c 3b 00 00 call 10d6a0 <_CORE_message_queue_Insert_message> <== NOT EXECUTED 109b04: 31 c0 xor %eax,%eax <== NOT EXECUTED 109b06: eb 56 jmp 109b5e <_CORE_message_queue_Submit+0xf2> <== NOT EXECUTED * No message buffers were available so we may need to return an * overflow error or block the sender until the message is placed * on the queue. */ if ( !wait ) { 109b08: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 109b0d: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 109b11: 74 55 je 109b68 <_CORE_message_queue_Submit+0xfc> <== NOT EXECUTED /* * Do NOT block on a send if the caller is in an ISR. It is * deadly to block in an ISR. */ if ( _ISR_Is_in_progress() ) { 109b13: a1 9c ca 11 00 mov 0x11ca9c,%eax <== NOT EXECUTED 109b18: 85 c0 test %eax,%eax <== NOT EXECUTED 109b1a: 75 47 jne 109b63 <_CORE_message_queue_Submit+0xf7> <== NOT EXECUTED * it as a variable. Doing this emphasizes how dangerous it * would be to use this variable prior to here. */ { Thread_Control *executing = _Thread_Executing; 109b1c: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED _ISR_Disable( level ); 109b21: 9c pushf <== NOT EXECUTED 109b22: fa cli <== NOT EXECUTED 109b23: 59 pop %ecx <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 109b24: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 109b27: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi) <== NOT EXECUTED _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; 109b2e: 89 70 44 mov %esi,0x44(%eax) <== NOT EXECUTED executing->Wait.id = id; 109b31: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 109b34: 89 50 20 mov %edx,0x20(%eax) <== NOT EXECUTED executing->Wait.return_argument_second.immutable_object = buffer; 109b37: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 109b3a: 89 50 2c mov %edx,0x2c(%eax) <== NOT EXECUTED executing->Wait.option = (uint32_t) size; 109b3d: 89 58 30 mov %ebx,0x30(%eax) <== NOT EXECUTED executing->Wait.count = submit_type; 109b40: 8b 75 1c mov 0x1c(%ebp),%esi <== NOT EXECUTED 109b43: 89 70 24 mov %esi,0x24(%eax) <== NOT EXECUTED _ISR_Enable( level ); 109b46: 51 push %ecx <== NOT EXECUTED 109b47: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 109b48: 50 push %eax <== NOT EXECUTED 109b49: 68 14 b5 10 00 push $0x10b514 <== NOT EXECUTED 109b4e: ff 75 24 pushl 0x24(%ebp) <== NOT EXECUTED 109b51: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109b54: e8 b7 16 00 00 call 10b210 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 109b59: b8 07 00 00 00 mov $0x7,%eax <== NOT EXECUTED 109b5e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109b61: eb 05 jmp 109b68 <_CORE_message_queue_Submit+0xfc> <== NOT EXECUTED } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; 109b63: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } 109b68: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109b6b: 5b pop %ebx <== NOT EXECUTED 109b6c: 5e pop %esi <== NOT EXECUTED 109b6d: 5f pop %edi <== NOT EXECUTED 109b6e: c9 leave <== NOT EXECUTED 109b6f: c3 ret <== NOT EXECUTED 00109b70 <_CORE_mutex_Flush>: void _CORE_mutex_Flush( CORE_mutex_Control *the_mutex, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 109b70: 55 push %ebp <== NOT EXECUTED 109b71: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Thread_queue_Flush( &the_mutex->Wait_queue, remote_extract_callout, status ); } 109b73: c9 leave <== NOT EXECUTED CORE_mutex_Control *the_mutex, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { _Thread_queue_Flush( 109b74: e9 a3 18 00 00 jmp 10b41c <_Thread_queue_Flush> <== NOT EXECUTED 00109b7c <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 109b7c: 55 push %ebp <== NOT EXECUTED 109b7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109b7f: 57 push %edi <== NOT EXECUTED 109b80: 56 push %esi <== NOT EXECUTED 109b81: 53 push %ebx <== NOT EXECUTED 109b82: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109b85: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 109b88: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 109b8b: 8d 7b 40 lea 0x40(%ebx),%edi <== NOT EXECUTED 109b8e: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 109b93: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 109b96: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED the_mutex->lock = initial_lock; 109b98: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED the_mutex->blocked_count = 0; 109b9b: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED if ( initial_lock == CORE_MUTEX_LOCKED ) { 109ba2: 85 c0 test %eax,%eax <== NOT EXECUTED 109ba4: 75 35 jne 109bdb <_CORE_mutex_Initialize+0x5f> <== NOT EXECUTED the_mutex->nest_count = 1; 109ba6: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx) <== NOT EXECUTED the_mutex->holder = _Thread_Executing; 109bad: 8b 15 c0 ca 11 00 mov 0x11cac0,%edx <== NOT EXECUTED 109bb3: 89 53 5c mov %edx,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = _Thread_Executing->Object.id; 109bb6: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 109bb9: 89 43 60 mov %eax,0x60(%ebx) <== NOT EXECUTED /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. * Any other value of @a alignment is taken "as is", i.e., even odd 109bbc: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 109bbf: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109bc2: 74 05 je 109bc9 <_CORE_mutex_Initialize+0x4d> <== NOT EXECUTED 109bc4: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 109bc7: 75 27 jne 109bf0 <_CORE_mutex_Initialize+0x74> <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < 109bc9: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED 109bcc: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 109bd1: 3b 43 4c cmp 0x4c(%ebx),%eax <== NOT EXECUTED 109bd4: 72 3a jb 109c10 <_CORE_mutex_Initialize+0x94> <== NOT EXECUTED _Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = _Thread_Executing->current_priority; #endif _Thread_Executing->resource_count++; 109bd6: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED 109bd9: eb 15 jmp 109bf0 <_CORE_mutex_Initialize+0x74> <== NOT EXECUTED } } else { the_mutex->nest_count = 0; 109bdb: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED the_mutex->holder = NULL; 109be2: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = 0; 109be9: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED } _Thread_queue_Initialize( 109bf0: 6a 05 push $0x5 <== NOT EXECUTED 109bf2: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 109bf7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 109bfa: 83 78 08 00 cmpl $0x0,0x8(%eax) <== NOT EXECUTED 109bfe: 0f 95 c0 setne %al <== NOT EXECUTED 109c01: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 109c04: 50 push %eax <== NOT EXECUTED 109c05: 53 push %ebx <== NOT EXECUTED 109c06: e8 39 18 00 00 call 10b444 <_Thread_queue_Initialize> <== NOT EXECUTED 109c0b: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 109c0d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 109c10: 89 c8 mov %ecx,%eax <== NOT EXECUTED 109c12: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109c15: 5b pop %ebx <== NOT EXECUTED 109c16: 5e pop %esi <== NOT EXECUTED 109c17: 5f pop %edi <== NOT EXECUTED 109c18: c9 leave <== NOT EXECUTED 109c19: c3 ret <== NOT EXECUTED 00109c68 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 109c68: 55 push %ebp <== NOT EXECUTED 109c69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109c6b: 56 push %esi <== NOT EXECUTED 109c6c: 53 push %ebx <== NOT EXECUTED 109c6d: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 109c70: 8a 5d 10 mov 0x10(%ebp),%bl <== NOT EXECUTED _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 109c73: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 109c78: 85 c0 test %eax,%eax <== NOT EXECUTED 109c7a: 74 19 je 109c95 <_CORE_mutex_Seize+0x2d> <== NOT EXECUTED 109c7c: 84 db test %bl,%bl <== NOT EXECUTED 109c7e: 74 15 je 109c95 <_CORE_mutex_Seize+0x2d> <== NOT EXECUTED 109c80: 83 3d a0 cb 11 00 01 cmpl $0x1,0x11cba0 <== NOT EXECUTED 109c87: 76 0c jbe 109c95 <_CORE_mutex_Seize+0x2d> <== NOT EXECUTED 109c89: 50 push %eax <== NOT EXECUTED 109c8a: 6a 13 push $0x13 <== NOT EXECUTED 109c8c: 6a 00 push $0x0 <== NOT EXECUTED 109c8e: 6a 00 push $0x0 <== NOT EXECUTED 109c90: e8 93 04 00 00 call 10a128 <_Internal_error_Occurred> <== NOT EXECUTED 109c95: 50 push %eax <== NOT EXECUTED 109c96: 50 push %eax <== NOT EXECUTED 109c97: 8d 45 18 lea 0x18(%ebp),%eax <== NOT EXECUTED 109c9a: 50 push %eax <== NOT EXECUTED 109c9b: 56 push %esi <== NOT EXECUTED 109c9c: e8 cb 3a 00 00 call 10d76c <_CORE_mutex_Seize_interrupt_trylock> <== NOT EXECUTED 109ca1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109ca4: 85 c0 test %eax,%eax <== NOT EXECUTED 109ca6: 74 49 je 109cf1 <_CORE_mutex_Seize+0x89> <== NOT EXECUTED 109ca8: 84 db test %bl,%bl <== NOT EXECUTED 109caa: 75 12 jne 109cbe <_CORE_mutex_Seize+0x56> <== NOT EXECUTED 109cac: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 109caf: 9d popf <== NOT EXECUTED 109cb0: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 109cb5: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) <== NOT EXECUTED 109cbc: eb 33 jmp 109cf1 <_CORE_mutex_Seize+0x89> <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 109cbe: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi) <== NOT EXECUTED 109cc5: 8b 15 c0 ca 11 00 mov 0x11cac0,%edx <== NOT EXECUTED 109ccb: 89 72 44 mov %esi,0x44(%edx) <== NOT EXECUTED 109cce: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 109cd1: 89 42 20 mov %eax,0x20(%edx) <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109cd4: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 109cd9: 40 inc %eax <== NOT EXECUTED 109cda: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED 109cdf: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 109ce2: 9d popf <== NOT EXECUTED 109ce3: 53 push %ebx <== NOT EXECUTED 109ce4: 53 push %ebx <== NOT EXECUTED 109ce5: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 109ce8: 56 push %esi <== NOT EXECUTED 109ce9: e8 2e ff ff ff call 109c1c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 109cee: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109cf1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109cf4: 5b pop %ebx <== NOT EXECUTED 109cf5: 5e pop %esi <== NOT EXECUTED 109cf6: c9 leave <== NOT EXECUTED 109cf7: c3 ret <== NOT EXECUTED 00109c1c <_CORE_mutex_Seize_interrupt_blocking>: void _CORE_mutex_Seize_interrupt_blocking( CORE_mutex_Control *the_mutex, Watchdog_Interval timeout ) { 109c1c: 55 push %ebp <== NOT EXECUTED 109c1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109c1f: 56 push %esi <== NOT EXECUTED 109c20: 53 push %ebx <== NOT EXECUTED 109c21: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 109c24: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 109c27: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 109c2c: 83 7b 48 02 cmpl $0x2,0x48(%ebx) <== NOT EXECUTED 109c30: 75 18 jne 109c4a <_CORE_mutex_Seize_interrupt_blocking+0x2e> <== NOT EXECUTED if ( the_mutex->holder->current_priority > executing->current_priority ) { 109c32: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED 109c35: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 109c38: 39 42 14 cmp %eax,0x14(%edx) <== NOT EXECUTED 109c3b: 76 0d jbe 109c4a <_CORE_mutex_Seize_interrupt_blocking+0x2e> <== NOT EXECUTED _Thread_Change_priority( 109c3d: 51 push %ecx <== NOT EXECUTED 109c3e: 6a 00 push $0x0 <== NOT EXECUTED 109c40: 50 push %eax <== NOT EXECUTED 109c41: 52 push %edx <== NOT EXECUTED 109c42: e8 d9 0c 00 00 call 10a920 <_Thread_Change_priority> <== NOT EXECUTED 109c47: 83 c4 10 add $0x10,%esp <== NOT EXECUTED FALSE ); } } the_mutex->blocked_count++; 109c4a: ff 43 58 incl 0x58(%ebx) <== NOT EXECUTED _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 109c4d: 50 push %eax <== NOT EXECUTED 109c4e: 68 14 b5 10 00 push $0x10b514 <== NOT EXECUTED 109c53: 56 push %esi <== NOT EXECUTED 109c54: 53 push %ebx <== NOT EXECUTED 109c55: e8 b6 15 00 00 call 10b210 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 109c5a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109c5d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109c60: 5b pop %ebx <== NOT EXECUTED 109c61: 5e pop %esi <== NOT EXECUTED 109c62: c9 leave <== NOT EXECUTED } the_mutex->blocked_count++; _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); _Thread_Enable_dispatch(); 109c63: e9 58 11 00 00 jmp 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 0010d76c <_CORE_mutex_Seize_interrupt_trylock>: #if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__) int _CORE_mutex_Seize_interrupt_trylock( CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { 10d76c: 55 push %ebp <== NOT EXECUTED 10d76d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d76f: 56 push %esi <== NOT EXECUTED 10d770: 53 push %ebx <== NOT EXECUTED 10d771: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED bool _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ); 10d774: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10d777: 8b 30 mov (%eax),%esi <== NOT EXECUTED /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. * 10d779: 8b 15 c0 ca 11 00 mov 0x11cac0,%edx <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10d77f: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10d786: 83 79 50 00 cmpl $0x0,0x50(%ecx) <== NOT EXECUTED 10d78a: 0f 84 82 00 00 00 je 10d812 <_CORE_mutex_Seize_interrupt_trylock+0xa6> <== NOT EXECUTED * to be resized 10d790: c7 41 50 00 00 00 00 movl $0x0,0x50(%ecx) <== NOT EXECUTED * @param[in] size is the new size 10d797: 89 51 5c mov %edx,0x5c(%ecx) <== NOT EXECUTED * 10d79a: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10d79d: 89 41 60 mov %eax,0x60(%ecx) <== NOT EXECUTED * @return TRUE if successfully able to resize the block. 10d7a0: c7 41 54 01 00 00 00 movl $0x1,0x54(%ecx) <== NOT EXECUTED /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. * Any other value of @a alignment is taken "as is", i.e., even odd 10d7a7: 8b 41 48 mov 0x48(%ecx),%eax <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block * to be resized * @param[in] size is the new size * * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. 10d7aa: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10d7ad: 74 05 je 10d7b4 <_CORE_mutex_Seize_interrupt_trylock+0x48> <== NOT EXECUTED 10d7af: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10d7b2: 75 03 jne 10d7b7 <_CORE_mutex_Seize_interrupt_trylock+0x4b> <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10d7b4: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is * possible with the freeing of this routine is performed. * 10d7b7: 83 79 48 03 cmpl $0x3,0x48(%ecx) <== NOT EXECUTED 10d7bb: 74 04 je 10d7c1 <_CORE_mutex_Seize_interrupt_trylock+0x55> <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10d7bd: 56 push %esi <== NOT EXECUTED 10d7be: 9d popf <== NOT EXECUTED 10d7bf: eb 74 jmp 10d835 <_CORE_mutex_Seize_interrupt_trylock+0xc9> <== NOT EXECUTED void *start_address ); /** * This routine walks the heap to verify its integrity. * 10d7c1: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10d7c4: 3b 41 4c cmp 0x4c(%ecx),%eax <== NOT EXECUTED 10d7c7: 75 04 jne 10d7cd <_CORE_mutex_Seize_interrupt_trylock+0x61> <== NOT EXECUTED * @param[in] source is a user specified integer which may be used to 10d7c9: 56 push %esi <== NOT EXECUTED 10d7ca: 9d popf <== NOT EXECUTED 10d7cb: eb 68 jmp 10d835 <_CORE_mutex_Seize_interrupt_trylock+0xc9> <== NOT EXECUTED * indicate where in the application this was invoked from * @param[in] do_dump is set to TRUE if errors should be printed * @return TRUE if the test passed fine, FALSE otherwise. */ 10d7cd: 76 27 jbe 10d7f6 <_CORE_mutex_Seize_interrupt_trylock+0x8a> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10d7cf: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10d7d4: 40 inc %eax <== NOT EXECUTED 10d7d5: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED * indicate where in the application this was invoked from * @param[in] do_dump is set to TRUE if errors should be printed * @return TRUE if the test passed fine, FALSE otherwise. */ bool _Protected_heap_Walk( Heap_Control *the_heap, 10d7da: 56 push %esi <== NOT EXECUTED 10d7db: 9d popf <== NOT EXECUTED int source, 10d7dc: 50 push %eax <== NOT EXECUTED 10d7dd: 6a 00 push $0x0 <== NOT EXECUTED 10d7df: ff 71 4c pushl 0x4c(%ecx) <== NOT EXECUTED 10d7e2: ff 71 5c pushl 0x5c(%ecx) <== NOT EXECUTED 10d7e5: e8 36 d1 ff ff call 10a920 <_Thread_Change_priority> <== NOT EXECUTED bool do_dump ); /** * This routine walks the heap and tots up the free and allocated 10d7ea: e8 d1 d5 ff ff call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10d7ef: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d7f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d7f4: eb 48 jmp 10d83e <_CORE_mutex_Seize_interrupt_trylock+0xd2> <== NOT EXECUTED * sizes. * * @param[in] the_heap pointer to heap header * @param[in] the_info pointer to a status information area 10d7f6: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) <== NOT EXECUTED * 10d7fd: c7 41 50 01 00 00 00 movl $0x1,0x50(%ecx) <== NOT EXECUTED * @return true if successfully able to return information 10d804: c7 41 54 00 00 00 00 movl $0x0,0x54(%ecx) <== NOT EXECUTED */ 10d80b: ff 4a 1c decl 0x1c(%edx) <== NOT EXECUTED bool _Protected_heap_Get_information( 10d80e: 56 push %esi <== NOT EXECUTED 10d80f: 9d popf <== NOT EXECUTED 10d810: eb 23 jmp 10d835 <_CORE_mutex_Seize_interrupt_trylock+0xc9> <== NOT EXECUTED * in the specified heap. * * @param[in] the_heap pointer to heap header. * @param[in] info pointer to the free block information. * * @return free block information filled in. 10d812: 8b 59 5c mov 0x5c(%ecx),%ebx <== NOT EXECUTED 10d815: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 10d817: 75 20 jne 10d839 <_CORE_mutex_Seize_interrupt_trylock+0xcd> <== NOT EXECUTED */ 10d819: 8b 41 40 mov 0x40(%ecx),%eax <== NOT EXECUTED 10d81c: 85 c0 test %eax,%eax <== NOT EXECUTED 10d81e: 74 05 je 10d825 <_CORE_mutex_Seize_interrupt_trylock+0xb9> <== NOT EXECUTED 10d820: 48 dec %eax <== NOT EXECUTED 10d821: 75 16 jne 10d839 <_CORE_mutex_Seize_interrupt_trylock+0xcd> <== NOT EXECUTED 10d823: eb 07 jmp 10d82c <_CORE_mutex_Seize_interrupt_trylock+0xc0> <== NOT EXECUTED bool _Protected_heap_Get_free_information( Heap_Control *the_heap, 10d825: ff 41 54 incl 0x54(%ecx) <== NOT EXECUTED Heap_Information *info 10d828: 56 push %esi <== NOT EXECUTED 10d829: 9d popf <== NOT EXECUTED 10d82a: eb 09 jmp 10d835 <_CORE_mutex_Seize_interrupt_trylock+0xc9> <== NOT EXECUTED ); #ifdef __cplusplus 10d82c: c7 43 34 02 00 00 00 movl $0x2,0x34(%ebx) <== NOT EXECUTED } 10d833: 56 push %esi <== NOT EXECUTED 10d834: 9d popf <== NOT EXECUTED 10d835: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d837: eb 05 jmp 10d83e <_CORE_mutex_Seize_interrupt_trylock+0xd2> <== NOT EXECUTED 10d839: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); } 10d83e: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d841: 5b pop %ebx <== NOT EXECUTED 10d842: 5e pop %esi <== NOT EXECUTED 10d843: c9 leave <== NOT EXECUTED 10d844: c3 ret <== NOT EXECUTED 00109cf8 <_CORE_mutex_Surrender>: CORE_mutex_Status _CORE_mutex_Surrender( CORE_mutex_Control *the_mutex, Objects_Id id, CORE_mutex_API_mp_support_callout api_mutex_mp_support ) { 109cf8: 55 push %ebp <== NOT EXECUTED 109cf9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109cfb: 53 push %ebx <== NOT EXECUTED 109cfc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 109cff: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Thread_Control *the_thread; Thread_Control *holder; #ifdef __RTEMS_STRICT_ORDER_MUTEX__ Chain_Node *first_node; #endif holder = the_mutex->holder; 109d02: 8b 4b 5c mov 0x5c(%ebx),%ecx <== NOT EXECUTED * allowed when the mutex in quetion is FIFO or simple Priority * discipline. But Priority Ceiling or Priority Inheritance mutexes * must be released by the thread which acquired them. */ if ( the_mutex->Attributes.only_owner_release ) { 109d05: 80 7b 44 00 cmpb $0x0,0x44(%ebx) <== NOT EXECUTED 109d09: 74 11 je 109d1c <_CORE_mutex_Surrender+0x24> <== NOT EXECUTED if ( !_Thread_Is_executing( holder ) ) 109d0b: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 109d10: 3b 0d c0 ca 11 00 cmp 0x11cac0,%ecx <== NOT EXECUTED 109d16: 0f 85 cb 00 00 00 jne 109de7 <_CORE_mutex_Surrender+0xef> <== NOT EXECUTED return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; } /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) 109d1c: 8b 43 54 mov 0x54(%ebx),%eax <== NOT EXECUTED 109d1f: 85 c0 test %eax,%eax <== NOT EXECUTED 109d21: 0f 84 be 00 00 00 je 109de5 <_CORE_mutex_Surrender+0xed> <== NOT EXECUTED return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 109d27: 48 dec %eax <== NOT EXECUTED 109d28: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED if ( the_mutex->nest_count != 0 ) { 109d2b: 85 c0 test %eax,%eax <== NOT EXECUTED 109d2d: 74 17 je 109d46 <_CORE_mutex_Surrender+0x4e> <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 109d2f: 8b 53 40 mov 0x40(%ebx),%edx <== NOT EXECUTED 109d32: 85 d2 test %edx,%edx <== NOT EXECUTED 109d34: 0f 84 ab 00 00 00 je 109de5 <_CORE_mutex_Surrender+0xed> <== NOT EXECUTED 109d3a: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 109d3f: 4a dec %edx <== NOT EXECUTED 109d40: 0f 84 a1 00 00 00 je 109de7 <_CORE_mutex_Surrender+0xef> <== NOT EXECUTED /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. * Any other value of @a alignment is taken "as is", i.e., even odd 109d46: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED /* * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 109d49: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109d4c: 74 05 je 109d53 <_CORE_mutex_Surrender+0x5b> <== NOT EXECUTED 109d4e: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 109d51: 75 03 jne 109d56 <_CORE_mutex_Surrender+0x5e> <== NOT EXECUTED the_mutex->nest_count++; return CORE_MUTEX_RELEASE_NOT_ORDER; } first_node = _Chain_Get_first_unprotected(&holder->lock_mutex); #endif holder->resource_count--; 109d53: ff 49 1c decl 0x1c(%ecx) <== NOT EXECUTED } the_mutex->holder = NULL; 109d56: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = 0; 109d5d: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED 109d64: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED /* * Whether or not someone is waiting for the mutex, an * inherited priority must be lowered if this is the last * mutex (i.e. resource) this task has. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 109d67: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109d6a: 74 05 je 109d71 <_CORE_mutex_Surrender+0x79> <== NOT EXECUTED 109d6c: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 109d6f: 75 1b jne 109d8c <_CORE_mutex_Surrender+0x94> <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { #ifdef __RTEMS_STRICT_ORDER_MUTEX__ if(the_mutex->queue.priority_before != holder->current_priority) _Thread_Change_priority(holder,the_mutex->queue.priority_before,TRUE); #endif if ( holder->resource_count == 0 && 109d71: 83 79 1c 00 cmpl $0x0,0x1c(%ecx) <== NOT EXECUTED 109d75: 75 15 jne 109d8c <_CORE_mutex_Surrender+0x94> <== NOT EXECUTED 109d77: 8b 41 18 mov 0x18(%ecx),%eax <== NOT EXECUTED 109d7a: 3b 41 14 cmp 0x14(%ecx),%eax <== NOT EXECUTED 109d7d: 74 0d je 109d8c <_CORE_mutex_Surrender+0x94> <== NOT EXECUTED holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 109d7f: 52 push %edx <== NOT EXECUTED 109d80: 6a 01 push $0x1 <== NOT EXECUTED 109d82: 50 push %eax <== NOT EXECUTED 109d83: 51 push %ecx <== NOT EXECUTED 109d84: e8 97 0b 00 00 call 10a920 <_Thread_Change_priority> <== NOT EXECUTED 109d89: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Now we check if another thread was waiting for this mutex. If so, * transfer the mutex to that thread. */ if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) { 109d8c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109d8f: 53 push %ebx <== NOT EXECUTED 109d90: e8 63 13 00 00 call 10b0f8 <_Thread_queue_Dequeue> <== NOT EXECUTED 109d95: 89 c2 mov %eax,%edx <== NOT EXECUTED 109d97: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109d9a: 85 c0 test %eax,%eax <== NOT EXECUTED 109d9c: 74 40 je 109dde <_CORE_mutex_Surrender+0xe6> <== NOT EXECUTED } else #endif { the_mutex->holder = the_thread; 109d9e: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = the_thread->Object.id; 109da1: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 109da4: 89 43 60 mov %eax,0x60(%ebx) <== NOT EXECUTED the_mutex->nest_count = 1; 109da7: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx) <== NOT EXECUTED switch ( the_mutex->Attributes.discipline ) { 109dae: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 109db1: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109db4: 74 07 je 109dbd <_CORE_mutex_Surrender+0xc5> <== NOT EXECUTED 109db6: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 109db9: 75 2a jne 109de5 <_CORE_mutex_Surrender+0xed> <== NOT EXECUTED 109dbb: eb 05 jmp 109dc2 <_CORE_mutex_Surrender+0xca> <== NOT EXECUTED case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: #ifdef __RTEMS_STRICT_ORDER_MUTEX__ _Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue); the_mutex->queue.priority_before = the_thread->current_priority; #endif the_thread->resource_count++; 109dbd: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED 109dc0: eb 23 jmp 109de5 <_CORE_mutex_Surrender+0xed> <== NOT EXECUTED case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: #ifdef __RTEMS_STRICT_ORDER_MUTEX__ _Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue); the_mutex->queue.priority_before = the_thread->current_priority; #endif the_thread->resource_count++; 109dc2: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED if (the_mutex->Attributes.priority_ceiling < 109dc5: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 109dc8: 3b 42 14 cmp 0x14(%edx),%eax <== NOT EXECUTED 109dcb: 73 18 jae 109de5 <_CORE_mutex_Surrender+0xed> <== NOT EXECUTED the_thread->current_priority){ _Thread_Change_priority( 109dcd: 51 push %ecx <== NOT EXECUTED 109dce: 6a 00 push $0x0 <== NOT EXECUTED 109dd0: 50 push %eax <== NOT EXECUTED 109dd1: 52 push %edx <== NOT EXECUTED 109dd2: e8 49 0b 00 00 call 10a920 <_Thread_Change_priority> <== NOT EXECUTED 109dd7: 31 c0 xor %eax,%eax <== NOT EXECUTED 109dd9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109ddc: eb 09 jmp 109de7 <_CORE_mutex_Surrender+0xef> <== NOT EXECUTED } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 109dde: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx) <== NOT EXECUTED 109de5: 31 c0 xor %eax,%eax <== NOT EXECUTED return CORE_MUTEX_STATUS_SUCCESSFUL; } 109de7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109dea: c9 leave <== NOT EXECUTED 109deb: c3 ret <== NOT EXECUTED 00109dec <_CORE_semaphore_Flush>: void _CORE_semaphore_Flush( CORE_semaphore_Control *the_semaphore, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 109dec: 55 push %ebp <== NOT EXECUTED 109ded: 89 e5 mov %esp,%ebp <== NOT EXECUTED &the_semaphore->Wait_queue, remote_extract_callout, status ); } 109def: c9 leave <== NOT EXECUTED Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { _Thread_queue_Flush( 109df0: e9 27 16 00 00 jmp 10b41c <_Thread_queue_Flush> <== NOT EXECUTED 00109df8 <_CORE_semaphore_Initialize>: void _CORE_semaphore_Initialize( CORE_semaphore_Control *the_semaphore, CORE_semaphore_Attributes *the_semaphore_attributes, uint32_t initial_value ) { 109df8: 55 push %ebp <== NOT EXECUTED 109df9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109dfb: 53 push %ebx <== NOT EXECUTED 109dfc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 109dff: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 109e02: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED the_semaphore->Attributes = *the_semaphore_attributes; 109e05: 8b 1a mov (%edx),%ebx <== NOT EXECUTED 109e07: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 109e0a: 89 41 44 mov %eax,0x44(%ecx) <== NOT EXECUTED 109e0d: 89 59 40 mov %ebx,0x40(%ecx) <== NOT EXECUTED the_semaphore->count = initial_value; 109e10: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 109e13: 89 41 48 mov %eax,0x48(%ecx) <== NOT EXECUTED _Thread_queue_Initialize( 109e16: 6a 03 push $0x3 <== NOT EXECUTED 109e18: 68 00 02 00 00 push $0x200 <== NOT EXECUTED 109e1d: 31 c0 xor %eax,%eax <== NOT EXECUTED 109e1f: 83 7a 04 01 cmpl $0x1,0x4(%edx) <== NOT EXECUTED 109e23: 0f 94 c0 sete %al <== NOT EXECUTED 109e26: 50 push %eax <== NOT EXECUTED 109e27: 51 push %ecx <== NOT EXECUTED 109e28: e8 17 16 00 00 call 10b444 <_Thread_queue_Initialize> <== NOT EXECUTED 109e2d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _CORE_semaphore_Is_priority( the_semaphore_attributes ) ? THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_SEMAPHORE, CORE_SEMAPHORE_TIMEOUT ); } 109e30: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109e33: c9 leave <== NOT EXECUTED 109e34: c3 ret <== NOT EXECUTED 00109e38 <_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 ) { 109e38: 55 push %ebp <== NOT EXECUTED 109e39: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109e3b: 53 push %ebx <== NOT EXECUTED 109e3c: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 109e3f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 109e42: 53 push %ebx <== NOT EXECUTED 109e43: e8 b0 12 00 00 call 10b0f8 <_Thread_queue_Dequeue> <== NOT EXECUTED 109e48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109e4b: 31 d2 xor %edx,%edx <== NOT EXECUTED 109e4d: 85 c0 test %eax,%eax <== NOT EXECUTED 109e4f: 75 18 jne 109e69 <_CORE_semaphore_Surrender+0x31> <== NOT EXECUTED if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); 109e51: 9c pushf <== NOT EXECUTED 109e52: fa cli <== NOT EXECUTED 109e53: 59 pop %ecx <== NOT EXECUTED if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 109e54: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 109e57: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED 109e5c: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 109e5f: 73 06 jae 109e67 <_CORE_semaphore_Surrender+0x2f> <== NOT EXECUTED the_semaphore->count += 1; 109e61: 40 inc %eax <== NOT EXECUTED 109e62: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 109e65: 31 d2 xor %edx,%edx <== NOT EXECUTED else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); 109e67: 51 push %ecx <== NOT EXECUTED 109e68: 9d popf <== NOT EXECUTED } return status; } 109e69: 89 d0 mov %edx,%eax <== NOT EXECUTED 109e6b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109e6e: c9 leave <== NOT EXECUTED 109e6f: c3 ret <== NOT EXECUTED 00109a20 <_Chain_Append>: void _Chain_Append( Chain_Control *the_chain, Chain_Node *node ) { 109a20: 55 push %ebp <== NOT EXECUTED 109a21: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a23: 53 push %ebx <== NOT EXECUTED 109a24: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 109a27: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 109a2a: 9c pushf <== NOT EXECUTED 109a2b: fa cli <== NOT EXECUTED 109a2c: 5b pop %ebx <== NOT EXECUTED 109a2d: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 109a30: 89 02 mov %eax,(%edx) <== NOT EXECUTED 109a32: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 109a35: 89 51 08 mov %edx,0x8(%ecx) <== NOT EXECUTED 109a38: 89 10 mov %edx,(%eax) <== NOT EXECUTED 109a3a: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED _Chain_Append_unprotected( the_chain, node ); _ISR_Enable( level ); 109a3d: 53 push %ebx <== NOT EXECUTED 109a3e: 9d popf <== NOT EXECUTED } 109a3f: 5b pop %ebx <== NOT EXECUTED 109a40: c9 leave <== NOT EXECUTED 109a41: c3 ret <== NOT EXECUTED 0010d650 <_Chain_Extract>: */ void _Chain_Extract( Chain_Node *node ) { 10d650: 55 push %ebp <== NOT EXECUTED 10d651: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d653: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10d656: 9c pushf <== NOT EXECUTED 10d657: fa cli <== NOT EXECUTED 10d658: 59 pop %ecx <== NOT EXECUTED 10d659: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10d65b: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10d65e: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10d661: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Chain_Extract_unprotected( node ); _ISR_Enable( level ); 10d663: 51 push %ecx <== NOT EXECUTED 10d664: 9d popf <== NOT EXECUTED } 10d665: c9 leave <== NOT EXECUTED 10d666: c3 ret <== NOT EXECUTED 00109a44 <_Chain_Get>: */ Chain_Node *_Chain_Get( Chain_Control *the_chain ) { 109a44: 55 push %ebp <== NOT EXECUTED 109a45: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a47: 53 push %ebx <== NOT EXECUTED 109a48: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Chain_Node *return_node; return_node = NULL; _ISR_Disable( level ); 109a4b: 9c pushf <== NOT EXECUTED 109a4c: fa cli <== NOT EXECUTED 109a4d: 5b pop %ebx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 109a4e: 8b 11 mov (%ecx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( the_chain ) ) 109a50: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 109a53: 39 c2 cmp %eax,%edx <== NOT EXECUTED 109a55: 75 04 jne 109a5b <_Chain_Get+0x17> <== NOT EXECUTED 109a57: 31 d2 xor %edx,%edx <== NOT EXECUTED 109a59: eb 07 jmp 109a62 <_Chain_Get+0x1e> <== NOT EXECUTED 109a5b: 8b 02 mov (%edx),%eax <== NOT EXECUTED 109a5d: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 109a5f: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED return_node = _Chain_Get_first_unprotected( the_chain ); _ISR_Enable( level ); 109a62: 53 push %ebx <== NOT EXECUTED 109a63: 9d popf <== NOT EXECUTED return return_node; } 109a64: 89 d0 mov %edx,%eax <== NOT EXECUTED 109a66: 5b pop %ebx <== NOT EXECUTED 109a67: c9 leave <== NOT EXECUTED 109a68: c3 ret <== NOT EXECUTED 0010d668 <_Chain_Initialize>: Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 10d668: 55 push %ebp <== NOT EXECUTED 10d669: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d66b: 56 push %esi <== NOT EXECUTED 10d66c: 53 push %ebx <== NOT EXECUTED 10d66d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10d670: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10d673: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED size_t size ); /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the 10d676: 89 da mov %ebx,%edx <== NOT EXECUTED Chain_Node *current; Chain_Node *next; count = number_nodes; current = _Chain_Head( the_chain ); the_chain->permanent_null = NULL; 10d678: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED next = starting_address; 10d67f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10d682: eb 0a jmp 10d68e <_Chain_Initialize+0x26> <== NOT EXECUTED while ( count-- ) { current->next = next; 10d684: 89 02 mov %eax,(%edx) <== NOT EXECUTED next->previous = current; 10d686: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 10d689: 49 dec %ecx <== NOT EXECUTED 10d68a: 89 c2 mov %eax,%edx <== NOT EXECUTED 10d68c: 01 f0 add %esi,%eax <== NOT EXECUTED count = number_nodes; current = _Chain_Head( the_chain ); the_chain->permanent_null = NULL; next = starting_address; while ( count-- ) { 10d68e: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10d690: 75 f2 jne 10d684 <_Chain_Initialize+0x1c> <== NOT EXECUTED next->previous = current; current = next; next = (Chain_Node *) _Addresses_Add_offset( (void *) next, node_size ); } current->next = _Chain_Tail( the_chain ); 10d692: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 10d695: 89 02 mov %eax,(%edx) <== NOT EXECUTED the_chain->last = current; 10d697: 89 53 08 mov %edx,0x8(%ebx) <== NOT EXECUTED } 10d69a: 5b pop %ebx <== NOT EXECUTED 10d69b: 5e pop %esi <== NOT EXECUTED 10d69c: c9 leave <== NOT EXECUTED 10d69d: c3 ret <== NOT EXECUTED 001216e0 <_Chain_Insert>: void _Chain_Insert( Chain_Node *after_node, Chain_Node *node ) { 1216e0: 55 push %ebp <== NOT EXECUTED 1216e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1216e3: 53 push %ebx <== NOT EXECUTED 1216e4: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1216e7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 1216ea: 9c pushf <== NOT EXECUTED 1216eb: fa cli <== NOT EXECUTED 1216ec: 5b pop %ebx <== NOT EXECUTED 1216ed: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 1216f0: 8b 0a mov (%edx),%ecx <== NOT EXECUTED 1216f2: 89 02 mov %eax,(%edx) <== NOT EXECUTED 1216f4: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 1216f6: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED _Chain_Insert_unprotected( after_node, node ); _ISR_Enable( level ); 1216f9: 53 push %ebx <== NOT EXECUTED 1216fa: 9d popf <== NOT EXECUTED } 1216fb: 5b pop %ebx <== NOT EXECUTED 1216fc: c9 leave <== NOT EXECUTED 1216fd: c3 ret <== NOT EXECUTED 0010d5fd <_Debug_Is_enabled>: */ bool _Debug_Is_enabled( rtems_debug_control level ) { 10d5fd: 55 push %ebp <== NOT EXECUTED 10d5fe: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d600: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d603: 85 05 c4 ca 11 00 test %eax,0x11cac4 <== NOT EXECUTED 10d609: 0f 95 c0 setne %al <== NOT EXECUTED return (_Debug_Level & level) ? true : false; } 10d60c: c9 leave <== NOT EXECUTED 10d60d: c3 ret <== NOT EXECUTED 0010d5d0 <_Debug_Manager_initialization>: * * _Debug_Manager_initialization */ void _Debug_Manager_initialization( void ) { 10d5d0: 55 push %ebp <== NOT EXECUTED 10d5d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED void rtems_debug_disable ( rtems_debug_control to_be_disabled ) { _Debug_Level &= ~to_be_disabled; 10d5d3: c7 05 c4 ca 11 00 00 movl $0x0,0x11cac4 <== NOT EXECUTED 10d5da: 00 00 00 <== NOT EXECUTED */ void _Debug_Manager_initialization( void ) { rtems_debug_disable( RTEMS_DEBUG_ALL_MASK ); } 10d5dd: c9 leave <== NOT EXECUTED 10d5de: c3 ret <== NOT EXECUTED 0010d26c <_Dual_ported_memory_Manager_initialization>: */ void _Dual_ported_memory_Manager_initialization( uint32_t maximum_ports ) { 10d26c: 55 push %ebp <== NOT EXECUTED 10d26d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d26f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d272: 6a 04 push $0x4 <== NOT EXECUTED 10d274: 6a 00 push $0x0 <== NOT EXECUTED 10d276: 6a 1c push $0x1c <== NOT EXECUTED 10d278: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d27b: 6a 07 push $0x7 <== NOT EXECUTED 10d27d: 6a 02 push $0x2 <== NOT EXECUTED 10d27f: 68 74 cd 11 00 push $0x11cd74 <== NOT EXECUTED 10d284: e8 cf d3 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 10d289: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10d28c: c9 leave <== NOT EXECUTED 10d28d: c3 ret <== NOT EXECUTED 0010d290 <_Event_Manager_initialization>: * * This routine performs the initialization necessary for this manager. */ void _Event_Manager_initialization( void ) { 10d290: 55 push %ebp <== NOT EXECUTED 10d291: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10d293: c7 05 a8 cc 11 00 00 movl $0x0,0x11cca8 <== NOT EXECUTED 10d29a: 00 00 00 <== NOT EXECUTED */ #if defined(RTEMS_MULTIPROCESSING) _MPCI_Register_packet_processor( MP_PACKET_EVENT, _Event_MP_Process_packet ); #endif } 10d29d: c9 leave <== NOT EXECUTED 10d29e: c3 ret <== NOT EXECUTED 00108ba0 <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 108ba0: 55 push %ebp <== NOT EXECUTED 108ba1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108ba3: 57 push %edi <== NOT EXECUTED 108ba4: 56 push %esi <== NOT EXECUTED 108ba5: 53 push %ebx <== NOT EXECUTED 108ba6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108ba9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 108bac: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 108baf: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 108bb2: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED 108bb5: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 108bb8: 89 4d e8 mov %ecx,-0x18(%ebp) <== NOT EXECUTED rtems_event_set pending_events; ISR_Level level; RTEMS_API_Control *api; Thread_blocking_operation_States sync_state; executing = _Thread_Executing; 108bbb: 8b 1d c0 ca 11 00 mov 0x11cac0,%ebx <== NOT EXECUTED executing->Wait.return_code = RTEMS_SUCCESSFUL; 108bc1: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED api = executing->API_Extensions[ THREAD_API_RTEMS ]; 108bc8: 8b 93 f4 00 00 00 mov 0xf4(%ebx),%edx <== NOT EXECUTED 108bce: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED _ISR_Disable( level ); 108bd1: 9c pushf <== NOT EXECUTED 108bd2: fa cli <== NOT EXECUTED 108bd3: 5f pop %edi <== NOT EXECUTED pending_events = api->pending_events; 108bd4: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 108bd7: 8b 11 mov (%ecx),%edx <== NOT EXECUTED seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 108bd9: 89 c1 mov %eax,%ecx <== NOT EXECUTED 108bdb: 21 d1 and %edx,%ecx <== NOT EXECUTED 108bdd: 74 23 je 108c02 <_Event_Seize+0x62> <== NOT EXECUTED 108bdf: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 108be1: 74 08 je 108beb <_Event_Seize+0x4b> <== NOT EXECUTED 108be3: f7 c6 02 00 00 00 test $0x2,%esi <== NOT EXECUTED 108be9: 74 17 je 108c02 <_Event_Seize+0x62> <== NOT EXECUTED (seized_events == event_in || _Options_Is_any( option_set )) ) { api->pending_events = 108beb: 89 c8 mov %ecx,%eax <== NOT EXECUTED 108bed: f7 d0 not %eax <== NOT EXECUTED 108bef: 21 d0 and %edx,%eax <== NOT EXECUTED 108bf1: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 108bf4: 89 02 mov %eax,(%edx) <== NOT EXECUTED _Event_sets_Clear( pending_events, seized_events ); _ISR_Enable( level ); 108bf6: 57 push %edi <== NOT EXECUTED 108bf7: 9d popf <== NOT EXECUTED *event_out = seized_events; 108bf8: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 108bfb: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 108bfd: e9 ad 00 00 00 jmp 108caf <_Event_Seize+0x10f> <== NOT EXECUTED return; } if ( _Options_Is_no_wait( option_set ) ) { 108c02: f7 c6 01 00 00 00 test $0x1,%esi <== NOT EXECUTED 108c08: 74 13 je 108c1d <_Event_Seize+0x7d> <== NOT EXECUTED _ISR_Enable( level ); 108c0a: 57 push %edi <== NOT EXECUTED 108c0b: 9d popf <== NOT EXECUTED executing->Wait.return_code = RTEMS_UNSATISFIED; 108c0c: c7 43 34 0d 00 00 00 movl $0xd,0x34(%ebx) <== NOT EXECUTED *event_out = seized_events; 108c13: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 108c16: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 108c18: e9 92 00 00 00 jmp 108caf <_Event_Seize+0x10f> <== NOT EXECUTED return; } _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 108c1d: c7 05 a8 cc 11 00 01 movl $0x1,0x11cca8 <== NOT EXECUTED 108c24: 00 00 00 <== NOT EXECUTED executing->Wait.option = (uint32_t) option_set; 108c27: 89 73 30 mov %esi,0x30(%ebx) <== NOT EXECUTED executing->Wait.count = (uint32_t) event_in; 108c2a: 89 43 24 mov %eax,0x24(%ebx) <== NOT EXECUTED executing->Wait.return_argument = event_out; 108c2d: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 108c30: 89 4b 28 mov %ecx,0x28(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 108c33: 57 push %edi <== NOT EXECUTED 108c34: 9d popf <== NOT EXECUTED if ( ticks ) { 108c35: 83 7d ec 00 cmpl $0x0,-0x14(%ebp) <== NOT EXECUTED 108c39: 74 34 je 108c6f <_Event_Seize+0xcf> <== NOT EXECUTED _Watchdog_Initialize( 108c3b: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 108c3e: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 108c45: c7 43 64 f0 8d 10 00 movl $0x108df0,0x64(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 108c4c: 89 43 68 mov %eax,0x68(%ebx) <== NOT EXECUTED * the heap 108c4f: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 108c56: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 108c59: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 108c5c: 52 push %edx <== NOT EXECUTED 108c5d: 52 push %edx <== NOT EXECUTED 108c5e: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 108c61: 50 push %eax <== NOT EXECUTED 108c62: 68 e0 ca 11 00 push $0x11cae0 <== NOT EXECUTED 108c67: e8 f0 2e 00 00 call 10bb5c <_Watchdog_Insert> <== NOT EXECUTED 108c6c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 108c6f: 50 push %eax <== NOT EXECUTED 108c70: 50 push %eax <== NOT EXECUTED 108c71: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 108c76: 53 push %ebx <== NOT EXECUTED 108c77: e8 34 29 00 00 call 10b5b0 <_Thread_Set_state> <== NOT EXECUTED _ISR_Disable( level ); 108c7c: 9c pushf <== NOT EXECUTED 108c7d: fa cli <== NOT EXECUTED 108c7e: 5a pop %edx <== NOT EXECUTED sync_state = _Event_Sync_state; 108c7f: a1 a8 cc 11 00 mov 0x11cca8,%eax <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 108c84: c7 05 a8 cc 11 00 00 movl $0x0,0x11cca8 <== NOT EXECUTED 108c8b: 00 00 00 <== NOT EXECUTED if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) { 108c8e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108c91: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 108c94: 75 04 jne 108c9a <_Event_Seize+0xfa> <== NOT EXECUTED _ISR_Enable( level ); 108c96: 52 push %edx <== NOT EXECUTED 108c97: 9d popf <== NOT EXECUTED 108c98: eb 15 jmp 108caf <_Event_Seize+0x10f> <== NOT EXECUTED * An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); 108c9a: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED 108c9d: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 108ca0: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 108ca3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108ca6: 5b pop %ebx <== NOT EXECUTED 108ca7: 5e pop %esi <== NOT EXECUTED 108ca8: 5f pop %edi <== NOT EXECUTED 108ca9: c9 leave <== NOT EXECUTED * An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); 108caa: e9 25 1c 00 00 jmp 10a8d4 <_Thread_blocking_operation_Cancel> <== NOT EXECUTED } 108caf: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108cb2: 5b pop %ebx <== NOT EXECUTED 108cb3: 5e pop %esi <== NOT EXECUTED 108cb4: 5f pop %edi <== NOT EXECUTED 108cb5: c9 leave <== NOT EXECUTED 108cb6: c3 ret <== NOT EXECUTED 00108d04 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 108d04: 55 push %ebp <== NOT EXECUTED 108d05: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108d07: 57 push %edi <== NOT EXECUTED 108d08: 56 push %esi <== NOT EXECUTED 108d09: 53 push %ebx <== NOT EXECUTED 108d0a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108d0d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 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 ]; 108d10: 8b 83 f4 00 00 00 mov 0xf4(%ebx),%eax <== NOT EXECUTED 108d16: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED option_set = (rtems_option) the_thread->Wait.option; 108d19: 8b 53 30 mov 0x30(%ebx),%edx <== NOT EXECUTED 108d1c: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED _ISR_Disable( level ); 108d1f: 9c pushf <== NOT EXECUTED 108d20: fa cli <== NOT EXECUTED 108d21: 5f pop %edi <== NOT EXECUTED pending_events = api->pending_events; 108d22: 8b 30 mov (%eax),%esi <== NOT EXECUTED event_condition = (rtems_event_set) the_thread->Wait.count; 108d24: 8b 53 24 mov 0x24(%ebx),%edx <== NOT EXECUTED seized_events = _Event_sets_Get( pending_events, event_condition ); /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { 108d27: 89 d1 mov %edx,%ecx <== NOT EXECUTED 108d29: 21 f1 and %esi,%ecx <== NOT EXECUTED 108d2b: 75 07 jne 108d34 <_Event_Surrender+0x30> <== NOT EXECUTED _ISR_Enable( level ); 108d2d: 57 push %edi <== NOT EXECUTED 108d2e: 9d popf <== NOT EXECUTED 108d2f: e9 b1 00 00 00 jmp 108de5 <_Event_Surrender+0xe1> <== NOT EXECUTED /* * 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() && 108d34: a1 9c ca 11 00 mov 0x11ca9c,%eax <== NOT EXECUTED 108d39: 85 c0 test %eax,%eax <== NOT EXECUTED 108d3b: 74 49 je 108d86 <_Event_Surrender+0x82> <== NOT EXECUTED 108d3d: 3b 1d c0 ca 11 00 cmp 0x11cac0,%ebx <== NOT EXECUTED 108d43: 75 41 jne 108d86 <_Event_Surrender+0x82> <== NOT EXECUTED 108d45: a1 a8 cc 11 00 mov 0x11cca8,%eax <== NOT EXECUTED 108d4a: 48 dec %eax <== NOT EXECUTED 108d4b: 74 0a je 108d57 <_Event_Surrender+0x53> <== NOT EXECUTED 108d4d: a1 a8 cc 11 00 mov 0x11cca8,%eax <== NOT EXECUTED 108d52: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 108d55: 75 2f jne 108d86 <_Event_Surrender+0x82> <== NOT EXECUTED _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 108d57: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 108d59: 74 06 je 108d61 <_Event_Surrender+0x5d> <== NOT EXECUTED 108d5b: f6 45 ec 02 testb $0x2,-0x14(%ebp) <== NOT EXECUTED 108d5f: 74 21 je 108d82 <_Event_Surrender+0x7e> <== NOT EXECUTED api->pending_events = _Event_sets_Clear( pending_events,seized_events ); 108d61: 89 c8 mov %ecx,%eax <== NOT EXECUTED 108d63: f7 d0 not %eax <== NOT EXECUTED 108d65: 21 f0 and %esi,%eax <== NOT EXECUTED 108d67: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 108d6a: 89 02 mov %eax,(%edx) <== NOT EXECUTED the_thread->Wait.count = 0; 108d6c: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) <== NOT EXECUTED *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 108d73: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 108d76: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 108d78: c7 05 a8 cc 11 00 03 movl $0x3,0x11cca8 <== NOT EXECUTED 108d7f: 00 00 00 <== NOT EXECUTED } _ISR_Enable( level ); 108d82: 57 push %edi <== NOT EXECUTED 108d83: 9d popf <== NOT EXECUTED 108d84: eb 5f jmp 108de5 <_Event_Surrender+0xe1> <== NOT EXECUTED } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 108d86: f6 43 11 01 testb $0x1,0x11(%ebx) <== NOT EXECUTED 108d8a: 74 57 je 108de3 <_Event_Surrender+0xdf> <== NOT EXECUTED if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 108d8c: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 108d8e: 74 06 je 108d96 <_Event_Surrender+0x92> <== NOT EXECUTED 108d90: f6 45 ec 02 testb $0x2,-0x14(%ebp) <== NOT EXECUTED 108d94: 74 4d je 108de3 <_Event_Surrender+0xdf> <== NOT EXECUTED api->pending_events = _Event_sets_Clear( pending_events, seized_events ); 108d96: 89 c8 mov %ecx,%eax <== NOT EXECUTED 108d98: f7 d0 not %eax <== NOT EXECUTED 108d9a: 21 f0 and %esi,%eax <== NOT EXECUTED 108d9c: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 108d9f: 89 02 mov %eax,(%edx) <== NOT EXECUTED the_thread->Wait.count = 0; 108da1: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) <== NOT EXECUTED *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 108da8: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 108dab: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _ISR_Flash( level ); 108dad: 57 push %edi <== NOT EXECUTED 108dae: 9d popf <== NOT EXECUTED 108daf: fa cli <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 108db0: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 108db4: 74 06 je 108dbc <_Event_Surrender+0xb8> <== NOT EXECUTED _ISR_Enable( level ); 108db6: 57 push %edi <== NOT EXECUTED 108db7: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 108db8: 51 push %ecx <== NOT EXECUTED 108db9: 51 push %ecx <== NOT EXECUTED 108dba: eb 17 jmp 108dd3 <_Event_Surrender+0xcf> <== NOT EXECUTED * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 108dbc: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 108dc3: 57 push %edi <== NOT EXECUTED 108dc4: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 108dc5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108dc8: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 108dcb: 50 push %eax <== NOT EXECUTED 108dcc: e8 a3 2e 00 00 call 10bc74 <_Watchdog_Remove> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 108dd1: 58 pop %eax <== NOT EXECUTED 108dd2: 5a pop %edx <== NOT EXECUTED 108dd3: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 108dd8: 53 push %ebx <== NOT EXECUTED 108dd9: e8 62 1c 00 00 call 10aa40 <_Thread_Clear_state> <== NOT EXECUTED 108dde: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108de1: eb 02 jmp 108de5 <_Event_Surrender+0xe1> <== NOT EXECUTED _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 108de3: 57 push %edi <== NOT EXECUTED 108de4: 9d popf <== NOT EXECUTED } 108de5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108de8: 5b pop %ebx <== NOT EXECUTED 108de9: 5e pop %esi <== NOT EXECUTED 108dea: 5f pop %edi <== NOT EXECUTED 108deb: c9 leave <== NOT EXECUTED 108dec: c3 ret <== NOT EXECUTED 00108df0 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 108df0: 55 push %ebp <== NOT EXECUTED 108df1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108df3: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 108df6: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 108df9: 50 push %eax <== NOT EXECUTED 108dfa: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 108dfd: e8 de 1f 00 00 call 10ade0 <_Thread_Get> <== NOT EXECUTED 108e02: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 108e04: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108e07: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 108e0b: 75 5f jne 108e6c <_Event_Timeout+0x7c> <== NOT EXECUTED * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ _ISR_Disable( level ); 108e0d: 9c pushf <== NOT EXECUTED 108e0e: fa cli <== NOT EXECUTED 108e0f: 59 pop %ecx <== NOT EXECUTED if ( !the_thread->Wait.count ) { /* verify thread is waiting */ 108e10: 83 78 24 00 cmpl $0x0,0x24(%eax) <== NOT EXECUTED 108e14: 75 0f jne 108e25 <_Event_Timeout+0x35> <== NOT EXECUTED 108e16: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 108e1b: 48 dec %eax <== NOT EXECUTED 108e1c: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED _Thread_Unnest_dispatch(); _ISR_Enable( level ); 108e21: 51 push %ecx <== NOT EXECUTED 108e22: 9d popf <== NOT EXECUTED 108e23: eb 47 jmp 108e6c <_Event_Timeout+0x7c> <== NOT EXECUTED return; } the_thread->Wait.count = 0; 108e25: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) <== NOT EXECUTED if ( _Thread_Is_executing( the_thread ) ) { 108e2c: 3b 05 c0 ca 11 00 cmp 0x11cac0,%eax <== NOT EXECUTED 108e32: 75 14 jne 108e48 <_Event_Timeout+0x58> <== NOT EXECUTED Thread_blocking_operation_States sync = _Event_Sync_state; 108e34: a1 a8 cc 11 00 mov 0x11cca8,%eax <== NOT EXECUTED if ( (sync == THREAD_BLOCKING_OPERATION_SYNCHRONIZED) || 108e39: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 108e3c: 77 0a ja 108e48 <_Event_Timeout+0x58> <== NOT EXECUTED (sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 108e3e: c7 05 a8 cc 11 00 02 movl $0x2,0x11cca8 <== NOT EXECUTED 108e45: 00 00 00 <== NOT EXECUTED } } the_thread->Wait.return_code = RTEMS_TIMEOUT; 108e48: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) <== NOT EXECUTED _ISR_Enable( level ); 108e4f: 51 push %ecx <== NOT EXECUTED 108e50: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 108e51: 50 push %eax <== NOT EXECUTED 108e52: 50 push %eax <== NOT EXECUTED 108e53: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 108e58: 52 push %edx <== NOT EXECUTED 108e59: e8 e2 1b 00 00 call 10aa40 <_Thread_Clear_state> <== NOT EXECUTED 108e5e: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 108e63: 48 dec %eax <== NOT EXECUTED 108e64: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED 108e69: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 108e6c: c9 leave <== NOT EXECUTED 108e6d: c3 ret <== NOT EXECUTED 0010973c <_Extension_Manager_initialization>: */ void _Extension_Manager_initialization( uint32_t maximum_extensions ) { 10973c: 55 push %ebp <== NOT EXECUTED 10973d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10973f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 109742: 6a 04 push $0x4 <== NOT EXECUTED 109744: 6a 00 push $0x0 <== NOT EXECUTED 109746: 6a 44 push $0x44 <== NOT EXECUTED 109748: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10974b: 6a 09 push $0x9 <== NOT EXECUTED 10974d: 6a 02 push $0x2 <== NOT EXECUTED 10974f: 68 ec cc 11 00 push $0x11ccec <== NOT EXECUTED 109754: e8 ff 0e 00 00 call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 109759: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , false, /* true if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10975c: c9 leave <== NOT EXECUTED 10975d: c3 ret <== NOT EXECUTED 0010d89c <_Heap_Allocate>: void *_Heap_Allocate( Heap_Control *the_heap, size_t size ) { 10d89c: 55 push %ebp <== NOT EXECUTED 10d89d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d89f: 57 push %edi <== NOT EXECUTED 10d8a0: 56 push %esi <== NOT EXECUTED 10d8a1: 53 push %ebx <== NOT EXECUTED 10d8a2: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10d8a5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Heap_Block *the_block; void *ptr = NULL; Heap_Statistics *const stats = &the_heap->stats; Heap_Block *const tail = _Heap_Tail(the_heap); the_size = 10d8a8: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 10d8ab: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 10d8ae: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d8b1: e8 b9 c7 ff ff call 10a06f <_Heap_Calc_block_size> <== NOT EXECUTED _Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size); if(the_size == 0) 10d8b6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d8b9: 31 d2 xor %edx,%edx <== NOT EXECUTED 10d8bb: 85 c0 test %eax,%eax <== NOT EXECUTED 10d8bd: 74 3c je 10d8fb <_Heap_Allocate+0x5f> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( 10d8bf: 8b 5e 08 mov 0x8(%esi),%ebx <== NOT EXECUTED 10d8c2: 31 ff xor %edi,%edi <== NOT EXECUTED 10d8c4: eb 27 jmp 10d8ed <_Heap_Allocate+0x51> <== NOT EXECUTED /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); /* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the result of the comparison. */ if(the_block->size >= the_size) { 10d8c6: 39 43 04 cmp %eax,0x4(%ebx) <== NOT EXECUTED 10d8c9: 72 1e jb 10d8e9 <_Heap_Allocate+0x4d> <== NOT EXECUTED (void)_Heap_Block_allocate(the_heap, the_block, the_size ); 10d8cb: 52 push %edx <== NOT EXECUTED 10d8cc: 50 push %eax <== NOT EXECUTED 10d8cd: 53 push %ebx <== NOT EXECUTED 10d8ce: 56 push %esi <== NOT EXECUTED 10d8cf: e8 d8 c7 ff ff call 10a0ac <_Heap_Block_allocate> <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 10d8d4: 8d 53 08 lea 0x8(%ebx),%edx <== NOT EXECUTED ptr = _Heap_User_area(the_block); stats->allocs += 1; 10d8d7: ff 46 48 incl 0x48(%esi) <== NOT EXECUTED stats->searches += search_count + 1; 10d8da: 8b 46 4c mov 0x4c(%esi),%eax <== NOT EXECUTED 10d8dd: 8d 44 07 01 lea 0x1(%edi,%eax,1),%eax <== NOT EXECUTED 10d8e1: 89 46 4c mov %eax,0x4c(%esi) <== NOT EXECUTED 10d8e4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d8e7: eb 0a jmp 10d8f3 <_Heap_Allocate+0x57> <== NOT EXECUTED return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; the_block = the_block->next, ++search_count) 10d8e9: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED 10d8ec: 47 inc %edi <== NOT EXECUTED if(the_size == 0) return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 10d8ed: 39 f3 cmp %esi,%ebx <== NOT EXECUTED 10d8ef: 75 d5 jne 10d8c6 <_Heap_Allocate+0x2a> <== NOT EXECUTED 10d8f1: 31 d2 xor %edx,%edx <== NOT EXECUTED _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; } } if(stats->max_search < search_count) 10d8f3: 39 7e 44 cmp %edi,0x44(%esi) <== NOT EXECUTED 10d8f6: 73 03 jae 10d8fb <_Heap_Allocate+0x5f> <== NOT EXECUTED stats->max_search = search_count; 10d8f8: 89 7e 44 mov %edi,0x44(%esi) <== NOT EXECUTED return ptr; } 10d8fb: 89 d0 mov %edx,%eax <== NOT EXECUTED 10d8fd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d900: 5b pop %ebx <== NOT EXECUTED 10d901: 5e pop %esi <== NOT EXECUTED 10d902: 5f pop %edi <== NOT EXECUTED 10d903: c9 leave <== NOT EXECUTED 10d904: c3 ret <== NOT EXECUTED 0010b72c <_Heap_Allocate_aligned>: void *_Heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ) { 10b72c: 55 push %ebp <== NOT EXECUTED 10b72d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b72f: 57 push %edi <== NOT EXECUTED 10b730: 56 push %esi <== NOT EXECUTED 10b731: 53 push %ebx <== NOT EXECUTED 10b732: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED 10b735: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED uint32_t search_count; Heap_Block *the_block; void *user_ptr = NULL; uint32_t const page_size = the_heap->page_size; 10b738: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b73b: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 10b73e: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED Heap_Statistics *const stats = &the_heap->stats; Heap_Block *const tail = _Heap_Tail(the_heap); uint32_t const end_to_user_offs = size - HEAP_BLOCK_HEADER_OFFSET; 10b741: 8d 48 fc lea -0x4(%eax),%ecx <== NOT EXECUTED 10b744: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED uint32_t const the_size = _Heap_Calc_block_size(size, page_size, the_heap->min_block_size); 10b747: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b74a: ff 72 14 pushl 0x14(%edx) <== NOT EXECUTED 10b74d: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED 10b750: 50 push %eax <== NOT EXECUTED 10b751: e8 2d 04 00 00 call 10bb83 <_Heap_Calc_block_size> <== NOT EXECUTED 10b756: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED if(the_size == 0) 10b759: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b75c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b75e: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) <== NOT EXECUTED 10b762: 0f 84 30 01 00 00 je 10b898 <_Heap_Allocate_aligned+0x16c> <== NOT EXECUTED return NULL; if(alignment == 0) 10b768: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 10b76c: 75 07 jne 10b775 <_Heap_Allocate_aligned+0x49> <== NOT EXECUTED 10b76e: c7 45 10 04 00 00 00 movl $0x4,0x10(%ebp) <== NOT EXECUTED ) { return ( the_thread == _Thread_Heir ); } /** 10b775: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b778: 8b 59 08 mov 0x8(%ecx),%ebx <== NOT EXECUTED 10b77b: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) <== NOT EXECUTED 10b782: e9 f8 00 00 00 jmp 10b87f <_Heap_Allocate_aligned+0x153> <== NOT EXECUTED 10b787: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10b78a: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 10b78d: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED uint32_t const block_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); if(block_size >= the_size) { /* the_block is large enough. */ 10b790: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10b793: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10b795: 0f 82 de 00 00 00 jb 10b879 <_Heap_Allocate_aligned+0x14d> <== NOT EXECUTED _H_uptr_t user_addr; _H_uptr_t aligned_user_addr; _H_uptr_t const user_area = _H_p2u(_Heap_User_area(the_block)); 10b79b: 8d 4b 08 lea 0x8(%ebx),%ecx <== NOT EXECUTED /* Calculate 'aligned_user_addr' that will become the user pointer we return. It should be at least 'end_to_user_offs' bytes less than the the 'block_end' and should be aligned on 'alignment' boundary. Calculations are from the 'block_end' as we are going to split free block so that the upper part of the block becomes used block. */ _H_uptr_t const block_end = _H_p2u(the_block) + block_size; 10b79e: 01 d8 add %ebx,%eax <== NOT EXECUTED 10b7a0: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED aligned_user_addr = block_end - end_to_user_offs; 10b7a3: 89 c6 mov %eax,%esi <== NOT EXECUTED 10b7a5: 2b 75 e0 sub -0x20(%ebp),%esi <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Dispatch_initialization( void ) { _Thread_Dispatch_disable_level = 1; } 10b7a8: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b7aa: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b7ac: f7 75 10 divl 0x10(%ebp) <== NOT EXECUTED 10b7af: 89 f7 mov %esi,%edi <== NOT EXECUTED 10b7b1: 29 d7 sub %edx,%edi <== NOT EXECUTED 10b7b3: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b7b5: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b7b7: f7 75 dc divl -0x24(%ebp) <== NOT EXECUTED 10b7ba: 89 fe mov %edi,%esi <== NOT EXECUTED 10b7bc: 29 d6 sub %edx,%esi <== NOT EXECUTED only at 'page_size' aligned addresses */ user_addr = aligned_user_addr; _Heap_Align_down_uptr(&user_addr, page_size); /* Make sure 'user_addr' calculated didn't run out of 'the_block'. */ if(user_addr >= user_area) { 10b7be: 39 ce cmp %ecx,%esi <== NOT EXECUTED 10b7c0: 0f 82 b3 00 00 00 jb 10b879 <_Heap_Allocate_aligned+0x14d> <== NOT EXECUTED /* The block seems to be acceptable. Check if the remainder of 'the_block' is less than 'min_block_size' so that 'the_block' won't actually be split at the address we assume. */ if(user_addr - user_area < the_heap->min_block_size) { 10b7c6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b7c9: 8b 52 14 mov 0x14(%edx),%edx <== NOT EXECUTED 10b7cc: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 10b7cf: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b7d1: 29 c8 sub %ecx,%eax <== NOT EXECUTED 10b7d3: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10b7d5: 73 2f jae 10b806 <_Heap_Allocate_aligned+0xda> <== NOT EXECUTED 'aligned_user_addr' to be outside of [0,page_size) range. If we do, we will need to store this distance somewhere to be able to resurrect the block address from the user pointer. (Having the distance within [0,page_size) range allows resurrection by aligning user pointer down to the nearest 'page_size' boundary.) */ if(aligned_user_addr - user_addr >= page_size) { 10b7d7: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b7d9: 29 c8 sub %ecx,%eax <== NOT EXECUTED 10b7db: 89 ce mov %ecx,%esi <== NOT EXECUTED 10b7dd: 3b 45 dc cmp -0x24(%ebp),%eax <== NOT EXECUTED 10b7e0: 72 24 jb 10b806 <_Heap_Allocate_aligned+0xda> <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); } /** 10b7e2: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b7e4: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b7e6: f7 75 10 divl 0x10(%ebp) <== NOT EXECUTED 10b7e9: 89 d6 mov %edx,%esi <== NOT EXECUTED * This function returns TRUE if dispatching is disabled, and FALSE 10b7eb: 89 ca mov %ecx,%edx <== NOT EXECUTED 10b7ed: 85 f6 test %esi,%esi <== NOT EXECUTED 10b7ef: 74 08 je 10b7f9 <_Heap_Allocate_aligned+0xcd> <== NOT EXECUTED 10b7f1: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b7f4: 8d 14 01 lea (%ecx,%eax,1),%edx <== NOT EXECUTED 10b7f7: 29 f2 sub %esi,%edx <== NOT EXECUTED /* The user pointer will be too far from 'user_addr'. See if we can make 'aligned_user_addr' to be close enough to the 'user_addr'. */ aligned_user_addr = user_addr; _Heap_Align_up_uptr(&aligned_user_addr, alignment); if(aligned_user_addr - user_addr >= page_size) { 10b7f9: 89 d0 mov %edx,%eax <== NOT EXECUTED 10b7fb: 29 c8 sub %ecx,%eax <== NOT EXECUTED 10b7fd: 3b 45 dc cmp -0x24(%ebp),%eax <== NOT EXECUTED 10b800: 73 77 jae 10b879 <_Heap_Allocate_aligned+0x14d> <== NOT EXECUTED 10b802: 89 ce mov %ecx,%esi <== NOT EXECUTED 10b804: 89 d7 mov %edx,%edi <== NOT EXECUTED aligned_user_addr = 0; } } } if(aligned_user_addr) { 10b806: 85 ff test %edi,%edi <== NOT EXECUTED 10b808: 74 6f je 10b879 <_Heap_Allocate_aligned+0x14d> <== NOT EXECUTED /* The block is indeed acceptable: calculate the size of the block to be allocated and perform allocation. */ uint32_t const alloc_size = block_end - user_addr + HEAP_BLOCK_USER_OFFSET; 10b80a: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10b80d: 83 c2 08 add $0x8,%edx <== NOT EXECUTED 10b810: 29 f2 sub %esi,%edx <== NOT EXECUTED Heap_Block *the_block, uint32_t alloc_size) { Heap_Statistics *const stats = &the_heap->stats; uint32_t const block_size = _Heap_Block_size(the_block); uint32_t const the_rest = block_size - alloc_size; 10b812: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 10b815: 29 d1 sub %edx,%ecx <== NOT EXECUTED _HAssert(_Heap_Is_aligned(block_size, the_heap->page_size)); _HAssert(_Heap_Is_aligned(alloc_size, the_heap->page_size)); _HAssert(alloc_size <= block_size); _HAssert(_Heap_Is_prev_used(the_block)); if(the_rest >= the_heap->min_block_size) { 10b817: 3b 4d f0 cmp -0x10(%ebp),%ecx <== NOT EXECUTED 10b81a: 72 14 jb 10b830 <_Heap_Allocate_aligned+0x104> <== NOT EXECUTED /* Split the block so that lower part is still free, and upper part becomes used. */ the_block->size = the_rest | HEAP_PREV_USED; 10b81c: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b81e: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10b821: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED Context_Control *context_p = &context_area; if ( _System_state_Is_up(_System_state_Get ()) ) context_p = &_Thread_Executing->Registers; _Context_Switch( context_p, &_Thread_BSP_context ); 10b824: 8d 04 0b lea (%ebx,%ecx,1),%eax <== NOT EXECUTED /** @brief _Thread_Is_proxy_blocking * * status which indicates that a proxy is blocking, and FALSE otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking ( uint32_t code 10b827: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_block = _Heap_Block_at(the_block, the_rest); the_block->prev_size = the_rest; 10b829: 89 08 mov %ecx,(%eax) <== NOT EXECUTED the_block->size = alloc_size; 10b82b: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 10b82e: eb 15 jmp 10b845 <_Heap_Allocate_aligned+0x119> <== NOT EXECUTED * This routine resets the current context of the calling thread * to that of its initial state. */ RTEMS_INLINE_ROUTINE void _Thread_Restart_self( void ) { 10b830: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) 10b833: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED if ( _Thread_Executing->fp_context != NULL ) 10b836: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED _Context_Restore_fp( &_Thread_Executing->fp_context ); 10b839: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED /* Don't split the block as remainder is either zero or too small to be used as a separate free block. Change 'alloc_size' to the size of the block and remove the block from the list of free blocks. */ _Heap_Block_remove(the_block); alloc_size = block_size; stats->free_blocks -= 1; 10b83c: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b83f: ff 4a 38 decl 0x38(%edx) <== NOT EXECUTED 10b842: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED } /* Mark the block as used (in the next block). */ _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED; 10b845: 83 4c 13 04 01 orl $0x1,0x4(%ebx,%edx,1) <== NOT EXECUTED /* Update statistics */ stats->free_size -= alloc_size; 10b84a: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b84d: 8b 41 30 mov 0x30(%ecx),%eax <== NOT EXECUTED 10b850: 29 d0 sub %edx,%eax <== NOT EXECUTED 10b852: 89 41 30 mov %eax,0x30(%ecx) <== NOT EXECUTED if(stats->min_free_size > stats->free_size) 10b855: 39 41 34 cmp %eax,0x34(%ecx) <== NOT EXECUTED 10b858: 76 03 jbe 10b85d <_Heap_Allocate_aligned+0x131> <== NOT EXECUTED stats->min_free_size = stats->free_size; 10b85a: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED stats->used_blocks += 1; 10b85d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b860: ff 40 40 incl 0x40(%eax) <== NOT EXECUTED _HAssert(_Heap_Is_aligned_ptr((void*)aligned_user_addr, alignment)); the_block = block_allocate(the_heap, the_block, alloc_size); stats->searches += search_count + 1; 10b863: 89 c2 mov %eax,%edx <== NOT EXECUTED 10b865: 8b 40 4c mov 0x4c(%eax),%eax <== NOT EXECUTED 10b868: 8b 4d d8 mov -0x28(%ebp),%ecx <== NOT EXECUTED 10b86b: 8d 44 01 01 lea 0x1(%ecx,%eax,1),%eax <== NOT EXECUTED 10b86f: 89 42 4c mov %eax,0x4c(%edx) <== NOT EXECUTED stats->allocs += 1; 10b872: ff 42 48 incl 0x48(%edx) <== NOT EXECUTED check_result(the_heap, the_block, user_addr, aligned_user_addr, size); user_ptr = (void*)aligned_user_addr; 10b875: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b877: eb 11 jmp 10b88a <_Heap_Allocate_aligned+0x15e> <== NOT EXECUTED /* Find large enough free block that satisfies the alignment requirements. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; the_block = the_block->next, ++search_count) 10b879: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED 10b87c: ff 45 d8 incl -0x28(%ebp) <== NOT EXECUTED alignment = CPU_ALIGNMENT; /* Find large enough free block that satisfies the alignment requirements. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 10b87f: 3b 5d 08 cmp 0x8(%ebp),%ebx <== NOT EXECUTED 10b882: 0f 85 ff fe ff ff jne 10b787 <_Heap_Allocate_aligned+0x5b> <== NOT EXECUTED 10b888: 31 c0 xor %eax,%eax <== NOT EXECUTED } } } } if(stats->max_search < search_count) 10b88a: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 10b88d: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b890: 39 51 44 cmp %edx,0x44(%ecx) <== NOT EXECUTED 10b893: 73 03 jae 10b898 <_Heap_Allocate_aligned+0x16c> <== NOT EXECUTED stats->max_search = search_count; 10b895: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED return user_ptr; } 10b898: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b89b: 5b pop %ebx <== NOT EXECUTED 10b89c: 5e pop %esi <== NOT EXECUTED 10b89d: 5f pop %edi <== NOT EXECUTED 10b89e: c9 leave <== NOT EXECUTED 10b89f: c3 ret <== NOT EXECUTED 0010a0ac <_Heap_Block_allocate>: uint32_t _Heap_Block_allocate( Heap_Control* the_heap, Heap_Block* the_block, uint32_t alloc_size ) { 10a0ac: 55 push %ebp <== NOT EXECUTED 10a0ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a0af: 57 push %edi <== NOT EXECUTED 10a0b0: 56 push %esi <== NOT EXECUTED 10a0b1: 53 push %ebx <== NOT EXECUTED 10a0b2: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10a0b5: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10a0b8: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10a0bb: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED Heap_Statistics *const stats = &the_heap->stats; uint32_t const block_size = _Heap_Block_size(the_block); uint32_t const the_rest = block_size - alloc_size; 10a0be: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10a0c0: 29 fb sub %edi,%ebx <== NOT EXECUTED _HAssert(_Heap_Is_aligned(block_size, the_heap->page_size)); _HAssert(_Heap_Is_aligned(alloc_size, the_heap->page_size)); _HAssert(alloc_size <= block_size); _HAssert(_Heap_Is_prev_used(the_block)); if(the_rest >= the_heap->min_block_size) { 10a0c2: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a0c5: 3b 5a 14 cmp 0x14(%edx),%ebx <== NOT EXECUTED 10a0c8: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED 10a0cb: 8b 56 0c mov 0xc(%esi),%edx <== NOT EXECUTED 10a0ce: 72 24 jb 10a0f4 <_Heap_Block_allocate+0x48> <== NOT EXECUTED 10a0d0: 8d 04 3e lea (%esi,%edi,1),%eax <== NOT EXECUTED * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size 10a0d3: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED ); 10a0d6: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED 10a0d9: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED 10a0dc: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED becomes used. This is slightly less optimal than leaving lower part free as it requires replacing block in the free blocks list, but it makes it possible to reuse this code in the _Heap_Resize_block(). */ Heap_Block *next_block = _Heap_Block_at(the_block, alloc_size); _Heap_Block_replace(the_block, next_block); the_block->size = alloc_size | HEAP_PREV_USED; 10a0df: 89 fa mov %edi,%edx <== NOT EXECUTED 10a0e1: 83 ca 01 or $0x1,%edx <== NOT EXECUTED 10a0e4: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED next_block->size = the_rest | HEAP_PREV_USED; 10a0e7: 89 da mov %ebx,%edx <== NOT EXECUTED 10a0e9: 83 ca 01 or $0x1,%edx <== NOT EXECUTED 10a0ec: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED _Heap_Block_at(next_block, the_rest)->prev_size = the_rest; 10a0ef: 89 1c 18 mov %ebx,(%eax,%ebx,1) <== NOT EXECUTED 10a0f2: eb 13 jmp 10a107 <_Heap_Block_allocate+0x5b> <== NOT EXECUTED * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @param[in] alignment the required alignment 10a0f4: 89 4a 08 mov %ecx,0x8(%edx) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10a0f7: 89 51 0c mov %edx,0xc(%ecx) <== NOT EXECUTED /* Don't split the block as remainder is either zero or too small to be used as a separate free block. Change 'alloc_size' to the size of the block and remove the block from the list of free blocks. */ _Heap_Block_remove(the_block); alloc_size = block_size; _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED; 10a0fa: 83 4c 06 04 01 orl $0x1,0x4(%esi,%eax,1) <== NOT EXECUTED stats->free_blocks -= 1; 10a0ff: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a102: ff 4a 38 decl 0x38(%edx) <== NOT EXECUTED 10a105: 89 c7 mov %eax,%edi <== NOT EXECUTED } /* Update statistics */ stats->free_size -= alloc_size; 10a107: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a10a: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10a10d: 29 f8 sub %edi,%eax <== NOT EXECUTED 10a10f: 89 42 30 mov %eax,0x30(%edx) <== NOT EXECUTED if(stats->min_free_size > stats->free_size) 10a112: 39 42 34 cmp %eax,0x34(%edx) <== NOT EXECUTED 10a115: 76 03 jbe 10a11a <_Heap_Block_allocate+0x6e> <== NOT EXECUTED stats->min_free_size = stats->free_size; 10a117: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED stats->used_blocks += 1; 10a11a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a11d: ff 40 40 incl 0x40(%eax) <== NOT EXECUTED return alloc_size; } 10a120: 89 f8 mov %edi,%eax <== NOT EXECUTED 10a122: 5b pop %ebx <== NOT EXECUTED 10a123: 5e pop %esi <== NOT EXECUTED 10a124: 5f pop %edi <== NOT EXECUTED 10a125: c9 leave <== NOT EXECUTED 10a126: c3 ret <== NOT EXECUTED 0010a06f <_Heap_Calc_block_size>: */ size_t _Heap_Calc_block_size( size_t size, uint32_t page_size, uint32_t min_size) { 10a06f: 55 push %ebp <== NOT EXECUTED 10a070: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a072: 57 push %edi <== NOT EXECUTED 10a073: 56 push %esi <== NOT EXECUTED 10a074: 53 push %ebx <== NOT EXECUTED 10a075: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a078: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10a07b: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10a07e: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED uint32_t block_size = size + HEAP_BLOCK_USED_OVERHEAD; 10a081: 8d 7e 04 lea 0x4(%esi),%edi <== NOT EXECUTED * sizes. * * @param[in] the_heap pointer to heap header * @param[in] the_info pointer to a status information area * * @return true if successfully able to return information 10a084: 89 f8 mov %edi,%eax <== NOT EXECUTED 10a086: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a088: f7 f1 div %ecx <== NOT EXECUTED */ 10a08a: 85 d2 test %edx,%edx <== NOT EXECUTED 10a08c: 74 05 je 10a093 <_Heap_Calc_block_size+0x24> <== NOT EXECUTED 10a08e: 8d 3c 39 lea (%ecx,%edi,1),%edi <== NOT EXECUTED 10a091: 29 d7 sub %edx,%edi <== NOT EXECUTED 10a093: 89 fa mov %edi,%edx <== NOT EXECUTED 10a095: 39 df cmp %ebx,%edi <== NOT EXECUTED 10a097: 73 02 jae 10a09b <_Heap_Calc_block_size+0x2c> <== NOT EXECUTED 10a099: 89 da mov %ebx,%edx <== NOT EXECUTED _Heap_Align_up(&block_size, page_size); if (block_size < min_size) block_size = min_size; /* 'block_size' becomes <= 'size' if and only if overflow occured. */ return (block_size > size) ? block_size : 0; 10a09b: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a09d: 39 f2 cmp %esi,%edx <== NOT EXECUTED 10a09f: 0f 97 c0 seta %al <== NOT EXECUTED 10a0a2: f7 d8 neg %eax <== NOT EXECUTED 10a0a4: 21 d0 and %edx,%eax <== NOT EXECUTED } 10a0a6: 5a pop %edx <== NOT EXECUTED 10a0a7: 5b pop %ebx <== NOT EXECUTED 10a0a8: 5e pop %esi <== NOT EXECUTED 10a0a9: 5f pop %edi <== NOT EXECUTED 10a0aa: c9 leave <== NOT EXECUTED 10a0ab: c3 ret <== NOT EXECUTED 0010f874 <_Heap_Extend>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t *amount_extended ) { 10f874: 55 push %ebp <== NOT EXECUTED 10f875: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f877: 57 push %edi <== NOT EXECUTED 10f878: 56 push %esi <== NOT EXECUTED 10f879: 53 push %ebx <== NOT EXECUTED 10f87a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f87d: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10f880: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10f883: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED * 5. non-contiguous higher address (NOT SUPPORTED) * * As noted, this code only supports (4). */ if ( starting_address >= the_heap->begin && /* case 3 */ 10f886: 3b 51 18 cmp 0x18(%ecx),%edx <== NOT EXECUTED 10f889: 72 0a jb 10f895 <_Heap_Extend+0x21> <== NOT EXECUTED 10f88b: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10f890: 3b 51 1c cmp 0x1c(%ecx),%edx <== NOT EXECUTED 10f893: 72 5f jb 10f8f4 <_Heap_Extend+0x80> <== NOT EXECUTED starting_address < the_heap->end ) return HEAP_EXTEND_ERROR; if ( starting_address != the_heap->end ) 10f895: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10f89a: 3b 51 1c cmp 0x1c(%ecx),%edx <== NOT EXECUTED 10f89d: 75 55 jne 10f8f4 <_Heap_Extend+0x80> <== NOT EXECUTED * Currently only case 4 should make it to this point. * The basic trick is to make the extend area look like a used * block and free it. */ old_final = the_heap->final; 10f89f: 8b 59 24 mov 0x24(%ecx),%ebx <== NOT EXECUTED Context_Control *context_p = &context_area; if ( _System_state_Is_up(_System_state_Get ()) ) context_p = &_Thread_Executing->Registers; _Context_Switch( context_p, &_Thread_BSP_context ); 10f8a2: 8d 04 32 lea (%edx,%esi,1),%eax <== NOT EXECUTED the_heap->end = _Addresses_Add_offset( the_heap->end, size ); 10f8a5: 89 41 1c mov %eax,0x1c(%ecx) <== NOT EXECUTED the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD; 10f8a8: 29 d8 sub %ebx,%eax <== NOT EXECUTED 10f8aa: 8d 78 f8 lea -0x8(%eax),%edi <== NOT EXECUTED * the outer most dispatching critical section, then a dispatching * operation will be performed and, if necessary, control of the * processor will be transferred to the heir thread. */ #if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \ 10f8ad: 89 f8 mov %edi,%eax <== NOT EXECUTED 10f8af: 31 d2 xor %edx,%edx <== NOT EXECUTED 10f8b1: f7 71 10 divl 0x10(%ecx) <== NOT EXECUTED 10f8b4: 29 d7 sub %edx,%edi <== NOT EXECUTED _Heap_Align_down( &the_size, the_heap->page_size ); *amount_extended = size; 10f8b6: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10f8b9: 89 30 mov %esi,(%eax) <== NOT EXECUTED if( the_size < the_heap->min_block_size ) 10f8bb: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f8bd: 3b 79 14 cmp 0x14(%ecx),%edi <== NOT EXECUTED 10f8c0: 72 32 jb 10f8f4 <_Heap_Extend+0x80> <== NOT EXECUTED return HEAP_EXTEND_SUCCESSFUL; old_final->size = the_size | (old_final->size & HEAP_PREV_USED); 10f8c2: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10f8c5: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10f8c8: 09 f8 or %edi,%eax <== NOT EXECUTED 10f8ca: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED /** @brief _Thread_Is_proxy_blocking * * status which indicates that a proxy is blocking, and FALSE otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking ( uint32_t code 10f8cd: 8d 04 3b lea (%ebx,%edi,1),%eax <== NOT EXECUTED new_final = _Heap_Block_at( old_final, the_size ); new_final->size = HEAP_PREV_USED; 10f8d0: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) <== NOT EXECUTED the_heap->final = new_final; 10f8d7: 89 41 24 mov %eax,0x24(%ecx) <== NOT EXECUTED stats->size += size; 10f8da: 01 71 2c add %esi,0x2c(%ecx) <== NOT EXECUTED stats->used_blocks += 1; 10f8dd: ff 41 40 incl 0x40(%ecx) <== NOT EXECUTED stats->frees -= 1; /* Don't count subsequent call as actual free() */ 10f8e0: ff 49 50 decl 0x50(%ecx) <== NOT EXECUTED _Heap_Free( the_heap, _Heap_User_area( old_final ) ); 10f8e3: 50 push %eax <== NOT EXECUTED 10f8e4: 50 push %eax <== NOT EXECUTED 10f8e5: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10f8e8: 50 push %eax <== NOT EXECUTED 10f8e9: 51 push %ecx <== NOT EXECUTED 10f8ea: e8 1d c0 ff ff call 10b90c <_Heap_Free> <== NOT EXECUTED 10f8ef: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f8f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return HEAP_EXTEND_SUCCESSFUL; } 10f8f4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f8f7: 5b pop %ebx <== NOT EXECUTED 10f8f8: 5e pop %esi <== NOT EXECUTED 10f8f9: 5f pop %edi <== NOT EXECUTED 10f8fa: c9 leave <== NOT EXECUTED 10f8fb: c3 ret <== NOT EXECUTED 0010d908 <_Heap_Free>: bool _Heap_Free( Heap_Control *the_heap, void *starting_address ) { 10d908: 55 push %ebp <== NOT EXECUTED 10d909: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d90b: 57 push %edi <== NOT EXECUTED 10d90c: 56 push %esi <== NOT EXECUTED 10d90d: 53 push %ebx <== NOT EXECUTED 10d90e: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10d911: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10d914: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED uint32_t the_size; uint32_t next_size; Heap_Statistics *const stats = &the_heap->stats; bool next_is_free; if ( !_Addresses_Is_in_range( 10d917: 8b 47 24 mov 0x24(%edi),%eax <== NOT EXECUTED 10d91a: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10d91d: 8b 57 20 mov 0x20(%edi),%edx <== NOT EXECUTED 10d920: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED 10d923: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 10d925: 0f 93 c2 setae %dl <== NOT EXECUTED 10d928: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10d92a: 0f 96 c0 setbe %al <== NOT EXECUTED 10d92d: 84 d0 test %dl,%al <== NOT EXECUTED 10d92f: 0f 84 2f 01 00 00 je 10da64 <_Heap_Free+0x15c> <== NOT EXECUTED 10d935: 8d 59 f8 lea -0x8(%ecx),%ebx <== NOT EXECUTED 10d938: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10d93a: 31 d2 xor %edx,%edx <== NOT EXECUTED 10d93c: f7 77 10 divl 0x10(%edi) <== NOT EXECUTED 10d93f: 29 d3 sub %edx,%ebx <== NOT EXECUTED return( FALSE ); } _Heap_Start_of_block( the_heap, starting_address, &the_block ); if ( !_Heap_Is_block_in( the_heap, the_block ) ) { 10d941: 3b 5d e4 cmp -0x1c(%ebp),%ebx <== NOT EXECUTED 10d944: 0f 93 c2 setae %dl <== NOT EXECUTED 10d947: 3b 5d e0 cmp -0x20(%ebp),%ebx <== NOT EXECUTED 10d94a: 0f 96 c0 setbe %al <== NOT EXECUTED 10d94d: 84 d0 test %dl,%al <== NOT EXECUTED 10d94f: 0f 84 0f 01 00 00 je 10da64 <_Heap_Free+0x15c> <== NOT EXECUTED 10d955: 8b 4b 04 mov 0x4(%ebx),%ecx <== NOT EXECUTED 10d958: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10d95a: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 10d95d: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 10d960: 8d 34 03 lea (%ebx,%eax,1),%esi <== NOT EXECUTED } the_size = _Heap_Block_size( the_block ); next_block = _Heap_Block_at( the_block, the_size ); if ( !_Heap_Is_block_in( the_heap, next_block ) ) { 10d963: 3b 75 e4 cmp -0x1c(%ebp),%esi <== NOT EXECUTED 10d966: 0f 93 c2 setae %dl <== NOT EXECUTED 10d969: 3b 75 e0 cmp -0x20(%ebp),%esi <== NOT EXECUTED 10d96c: 0f 96 c0 setbe %al <== NOT EXECUTED 10d96f: 84 d0 test %dl,%al <== NOT EXECUTED 10d971: 0f 84 ed 00 00 00 je 10da64 <_Heap_Free+0x15c> <== NOT EXECUTED 10d977: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED _HAssert( FALSE ); return( FALSE ); } if ( !_Heap_Is_prev_used( next_block ) ) { 10d97a: a8 01 test $0x1,%al <== NOT EXECUTED 10d97c: 0f 84 e2 00 00 00 je 10da64 <_Heap_Free+0x15c> <== NOT EXECUTED 10d982: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 10d985: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED _HAssert( FALSE ); return( FALSE ); } next_size = _Heap_Block_size( next_block ); next_is_free = next_block < the_heap->final && 10d988: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d98a: 3b 75 e0 cmp -0x20(%ebp),%esi <== NOT EXECUTED 10d98d: 73 0c jae 10d99b <_Heap_Free+0x93> <== NOT EXECUTED 10d98f: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10d992: 8b 44 16 04 mov 0x4(%esi,%edx,1),%eax <== NOT EXECUTED 10d996: f7 d0 not %eax <== NOT EXECUTED 10d998: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10d99b: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED !_Heap_Is_prev_used(_Heap_Block_at(next_block, next_size)); if ( !_Heap_Is_prev_used( the_block ) ) { 10d99e: 80 e1 01 and $0x1,%cl <== NOT EXECUTED 10d9a1: 75 56 jne 10d9f9 <_Heap_Free+0xf1> <== NOT EXECUTED uint32_t const prev_size = the_block->prev_size; 10d9a3: 8b 0b mov (%ebx),%ecx <== NOT EXECUTED 10d9a5: 29 cb sub %ecx,%ebx <== NOT EXECUTED Heap_Block *const prev_block = _Heap_Block_at( the_block, -prev_size ); if ( !_Heap_Is_block_in( the_heap, prev_block ) ) { 10d9a7: 3b 5d e4 cmp -0x1c(%ebp),%ebx <== NOT EXECUTED 10d9aa: 0f 93 c2 setae %dl <== NOT EXECUTED 10d9ad: 3b 5d e0 cmp -0x20(%ebp),%ebx <== NOT EXECUTED 10d9b0: 0f 96 c0 setbe %al <== NOT EXECUTED 10d9b3: 84 d0 test %dl,%al <== NOT EXECUTED 10d9b5: 0f 84 a9 00 00 00 je 10da64 <_Heap_Free+0x15c> <== NOT EXECUTED 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) ) { 10d9bb: f6 43 04 01 testb $0x1,0x4(%ebx) <== NOT EXECUTED 10d9bf: 0f 84 9f 00 00 00 je 10da64 <_Heap_Free+0x15c> <== NOT EXECUTED _HAssert( FALSE ); return( FALSE ); } if ( next_is_free ) { /* coalesce both */ 10d9c5: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10d9c9: 74 19 je 10d9e4 <_Heap_Free+0xdc> <== NOT EXECUTED uint32_t const size = the_size + prev_size + next_size; 10d9cb: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10d9ce: 03 55 ec add -0x14(%ebp),%edx <== NOT EXECUTED 10d9d1: 01 ca add %ecx,%edx <== NOT EXECUTED * Any other value of @a alignment is taken "as is", i.e., even odd * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon 10d9d3: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED * @param[in] size is the amount of memory to allocate in bytes 10d9d6: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED * @param[in] alignment the required alignment 10d9d9: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10d9dc: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED _Heap_Block_remove( next_block ); stats->free_blocks -= 1; 10d9df: ff 4f 38 decl 0x38(%edi) <== NOT EXECUTED 10d9e2: eb 33 jmp 10da17 <_Heap_Free+0x10f> <== NOT EXECUTED next_block = _Heap_Block_at( prev_block, size ); _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; } else { /* coalesce prev */ uint32_t const size = the_size + prev_size; 10d9e4: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10d9e7: 01 ca add %ecx,%edx <== NOT EXECUTED prev_block->size = size | HEAP_PREV_USED; 10d9e9: 89 d0 mov %edx,%eax <== NOT EXECUTED 10d9eb: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10d9ee: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block->size &= ~HEAP_PREV_USED; 10d9f1: 83 66 04 fe andl $0xfffffffe,0x4(%esi) <== NOT EXECUTED next_block->prev_size = size; 10d9f5: 89 16 mov %edx,(%esi) <== NOT EXECUTED 10d9f7: eb 5b jmp 10da54 <_Heap_Free+0x14c> <== NOT EXECUTED } } else if ( next_is_free ) { /* coalesce next */ 10d9f9: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10d9fd: 74 25 je 10da24 <_Heap_Free+0x11c> <== NOT EXECUTED uint32_t const size = the_size + next_size; 10d9ff: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10da02: 03 55 e8 add -0x18(%ebp),%edx <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ 10da05: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED bool _Protected_heap_Get_block_size( 10da08: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size 10da0b: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED ); 10da0e: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED 10da11: 89 58 08 mov %ebx,0x8(%eax) <== NOT EXECUTED 10da14: 89 59 0c mov %ebx,0xc(%ecx) <== NOT EXECUTED _Heap_Block_replace( next_block, the_block ); the_block->size = size | HEAP_PREV_USED; 10da17: 89 d0 mov %edx,%eax <== NOT EXECUTED 10da19: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10da1c: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block = _Heap_Block_at( the_block, size ); next_block->prev_size = size; 10da1f: 89 14 13 mov %edx,(%ebx,%edx,1) <== NOT EXECUTED 10da22: eb 30 jmp 10da54 <_Heap_Free+0x14c> <== NOT EXECUTED bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ); 10da24: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED /** 10da27: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED * This routine returns the block of memory which begins 10da2a: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10da2d: 89 5f 08 mov %ebx,0x8(%edi) <== NOT EXECUTED 10da30: 89 58 0c mov %ebx,0xc(%eax) <== NOT EXECUTED } else { /* no coalesce */ /* Add 'the_block' to the head of the free blocks list as it tends to produce less fragmentation than adding to the tail. */ _Heap_Block_insert_after( _Heap_Head( the_heap), the_block ); the_block->size = the_size | HEAP_PREV_USED; 10da33: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10da36: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10da39: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block->size &= ~HEAP_PREV_USED; 10da3c: 83 66 04 fe andl $0xfffffffe,0x4(%esi) <== NOT EXECUTED next_block->prev_size = the_size; 10da40: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10da43: 89 06 mov %eax,(%esi) <== NOT EXECUTED stats->free_blocks += 1; 10da45: 8b 47 38 mov 0x38(%edi),%eax <== NOT EXECUTED 10da48: 40 inc %eax <== NOT EXECUTED 10da49: 89 47 38 mov %eax,0x38(%edi) <== NOT EXECUTED if ( stats->max_free_blocks < stats->free_blocks ) 10da4c: 39 47 3c cmp %eax,0x3c(%edi) <== NOT EXECUTED 10da4f: 73 03 jae 10da54 <_Heap_Free+0x14c> <== NOT EXECUTED stats->max_free_blocks = stats->free_blocks; 10da51: 89 47 3c mov %eax,0x3c(%edi) <== NOT EXECUTED } stats->used_blocks -= 1; 10da54: ff 4f 40 decl 0x40(%edi) <== NOT EXECUTED stats->free_size += the_size; 10da57: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10da5a: 01 57 30 add %edx,0x30(%edi) <== NOT EXECUTED stats->frees += 1; 10da5d: ff 47 50 incl 0x50(%edi) <== NOT EXECUTED 10da60: b0 01 mov $0x1,%al <== NOT EXECUTED 10da62: eb 02 jmp 10da66 <_Heap_Free+0x15e> <== NOT EXECUTED return( TRUE ); 10da64: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10da66: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10da69: 5b pop %ebx <== NOT EXECUTED 10da6a: 5e pop %esi <== NOT EXECUTED 10da6b: 5f pop %edi <== NOT EXECUTED 10da6c: c9 leave <== NOT EXECUTED 10da6d: c3 ret <== NOT EXECUTED 00121b64 <_Heap_Get_free_information>: void _Heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 121b64: 55 push %ebp <== NOT EXECUTED 121b65: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121b67: 53 push %ebx <== NOT EXECUTED 121b68: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 121b6b: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED Heap_Block *the_block; Heap_Block *const tail = _Heap_Tail(the_heap); info->number = 0; 121b6e: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED info->largest = 0; 121b74: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED info->total = 0; 121b7b: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( 121b82: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 121b85: eb 16 jmp 121b9d <_Heap_Get_free_information+0x39> <== NOT EXECUTED 121b87: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 121b8a: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED uint32_t const the_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; 121b8d: ff 02 incl (%edx) <== NOT EXECUTED info->total += the_size; 121b8f: 01 42 08 add %eax,0x8(%edx) <== NOT EXECUTED if ( info->largest < the_size ) 121b92: 39 42 04 cmp %eax,0x4(%edx) <== NOT EXECUTED 121b95: 73 03 jae 121b9a <_Heap_Get_free_information+0x36> <== NOT EXECUTED info->largest = the_size; 121b97: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; the_block = the_block->next) 121b9a: 8b 49 08 mov 0x8(%ecx),%ecx <== NOT EXECUTED info->number = 0; info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; 121b9d: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 121b9f: 75 e6 jne 121b87 <_Heap_Get_free_information+0x23> <== NOT EXECUTED info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 121ba1: 5b pop %ebx <== NOT EXECUTED 121ba2: c9 leave <== NOT EXECUTED 121ba3: c3 ret <== NOT EXECUTED 001296e8 <_Heap_Get_information>: Heap_Get_information_status _Heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 1296e8: 55 push %ebp <== NOT EXECUTED 1296e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1296eb: 53 push %ebx <== NOT EXECUTED 1296ec: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1296ef: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED Heap_Block *the_block = the_heap->start; 1296f2: 8b 48 20 mov 0x20(%eax),%ecx <== NOT EXECUTED Heap_Block *const end = the_heap->final; 1296f5: 8b 58 24 mov 0x24(%eax),%ebx <== NOT EXECUTED _HAssert(the_block->prev_size == HEAP_PREV_USED); _HAssert(_Heap_Is_prev_used(the_block)); the_info->Free.number = 0; 1296f8: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED the_info->Free.total = 0; 1296fe: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) <== NOT EXECUTED the_info->Free.largest = 0; 129705: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED the_info->Used.number = 0; 12970c: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) <== NOT EXECUTED the_info->Used.total = 0; 129713: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx) <== NOT EXECUTED the_info->Used.largest = 0; 12971a: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED 129721: eb 36 jmp 129759 <_Heap_Get_information+0x71> <== NOT EXECUTED 129723: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 129726: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 129729: 01 c1 add %eax,%ecx <== NOT EXECUTED while ( the_block != end ) { uint32_t const the_size = _Heap_Block_size(the_block); Heap_Block *const next_block = _Heap_Block_at(the_block, the_size); if ( _Heap_Is_prev_used(next_block) ) { 12972b: f6 41 04 01 testb $0x1,0x4(%ecx) <== NOT EXECUTED 12972f: 74 10 je 129741 <_Heap_Get_information+0x59> <== NOT EXECUTED the_info->Used.number++; 129731: ff 42 0c incl 0xc(%edx) <== NOT EXECUTED the_info->Used.total += the_size; 129734: 01 42 14 add %eax,0x14(%edx) <== NOT EXECUTED if ( the_info->Used.largest < the_size ) 129737: 39 42 10 cmp %eax,0x10(%edx) <== NOT EXECUTED 12973a: 73 1d jae 129759 <_Heap_Get_information+0x71> <== NOT EXECUTED the_info->Used.largest = the_size; 12973c: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED 12973f: eb 18 jmp 129759 <_Heap_Get_information+0x71> <== NOT EXECUTED } else { the_info->Free.number++; 129741: ff 02 incl (%edx) <== NOT EXECUTED the_info->Free.total += the_size; 129743: 01 42 08 add %eax,0x8(%edx) <== NOT EXECUTED if ( the_info->Free.largest < the_size ) 129746: 39 42 04 cmp %eax,0x4(%edx) <== NOT EXECUTED 129749: 73 03 jae 12974e <_Heap_Get_information+0x66> <== NOT EXECUTED the_info->Free.largest = the_size; 12974b: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED if ( the_size != next_block->prev_size ) 12974e: 3b 01 cmp (%ecx),%eax <== NOT EXECUTED 129750: 74 07 je 129759 <_Heap_Get_information+0x71> <== NOT EXECUTED 129752: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 129757: eb 0a jmp 129763 <_Heap_Get_information+0x7b> <== NOT EXECUTED the_info->Free.largest = 0; the_info->Used.number = 0; the_info->Used.total = 0; the_info->Used.largest = 0; while ( the_block != end ) { 129759: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 12975b: 75 c6 jne 129723 <_Heap_Get_information+0x3b> <== NOT EXECUTED } /* Handle the last dummy block. Don't consider this block to be "used" as client never allocated it. Make 'Used.total' contain this blocks' overhead though. */ the_info->Used.total += HEAP_OVERHEAD; 12975d: 83 42 14 08 addl $0x8,0x14(%edx) <== NOT EXECUTED 129761: 31 c0 xor %eax,%eax <== NOT EXECUTED return HEAP_GET_INFORMATION_SUCCESSFUL; } 129763: 5b pop %ebx <== NOT EXECUTED 129764: c9 leave <== NOT EXECUTED 129765: c3 ret <== NOT EXECUTED 00109f60 <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 109f60: 55 push %ebp <== NOT EXECUTED 109f61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109f63: 57 push %edi <== NOT EXECUTED 109f64: 56 push %esi <== NOT EXECUTED 109f65: 53 push %ebx <== NOT EXECUTED 109f66: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109f69: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 109f6c: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 109f6f: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED _H_uptr_t start; _H_uptr_t aligned_start; uint32_t overhead; Heap_Statistics *const stats = &the_heap->stats; if (page_size == 0) 109f72: 85 c9 test %ecx,%ecx <== NOT EXECUTED 109f74: 75 04 jne 109f7a <_Heap_Initialize+0x1a> <== NOT EXECUTED 109f76: b1 04 mov $0x4,%cl <== NOT EXECUTED 109f78: eb 0c jmp 109f86 <_Heap_Initialize+0x26> <== NOT EXECUTED * * @param[in] the_heap pointer to heap header * @param[in] the_info pointer to a status information area * * @return true if successfully able to return information */ 109f7a: 89 c8 mov %ecx,%eax <== NOT EXECUTED 109f7c: 83 e0 03 and $0x3,%eax <== NOT EXECUTED 109f7f: 74 05 je 109f86 <_Heap_Initialize+0x26> <== NOT EXECUTED 109f81: 83 c1 04 add $0x4,%ecx <== NOT EXECUTED 109f84: 29 c1 sub %eax,%ecx <== NOT EXECUTED /* Calculate aligned_start so that aligned_start + HEAP_BLOCK_USER_OFFSET (value of user pointer) is aligned on 'page_size' boundary. Make sure resulting 'aligned_start' is not below 'starting_address'. */ start = _H_p2u(starting_address); aligned_start = start + HEAP_BLOCK_USER_OFFSET; 109f86: 8d 5f 08 lea 0x8(%edi),%ebx <== NOT EXECUTED 109f89: 89 d8 mov %ebx,%eax <== NOT EXECUTED 109f8b: 31 d2 xor %edx,%edx <== NOT EXECUTED 109f8d: f7 f1 div %ecx <== NOT EXECUTED 109f8f: 85 d2 test %edx,%edx <== NOT EXECUTED 109f91: 74 05 je 109f98 <_Heap_Initialize+0x38> <== NOT EXECUTED 109f93: 8d 1c 19 lea (%ecx,%ebx,1),%ebx <== NOT EXECUTED 109f96: 29 d3 sub %edx,%ebx <== NOT EXECUTED _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; 109f98: 83 eb 08 sub $0x8,%ebx <== NOT EXECUTED * sizes. * * @param[in] the_heap pointer to heap header * @param[in] the_info pointer to a status information area * * @return true if successfully able to return information 109f9b: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 109fa0: 31 d2 xor %edx,%edx <== NOT EXECUTED 109fa2: f7 f1 div %ecx <== NOT EXECUTED */ 109fa4: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 109fa9: 85 d2 test %edx,%edx <== NOT EXECUTED 109fab: 74 05 je 109fb2 <_Heap_Initialize+0x52> <== NOT EXECUTED 109fad: 8d 41 10 lea 0x10(%ecx),%eax <== NOT EXECUTED 109fb0: 29 d0 sub %edx,%eax <== NOT EXECUTED 109fb2: 89 46 14 mov %eax,0x14(%esi) <== NOT EXECUTED /* Calculate 'the_size' -- size of the first block so that there is enough space at the end for the permanent last block. It is equal to 'size' minus total overhead aligned down to the nearest multiple of 'page_size'. */ overhead = HEAP_OVERHEAD + (aligned_start - start); 109fb5: 89 d8 mov %ebx,%eax <== NOT EXECUTED 109fb7: 29 f8 sub %edi,%eax <== NOT EXECUTED 109fb9: 83 c0 08 add $0x8,%eax <== NOT EXECUTED if ( size < overhead ) 109fbc: 39 45 10 cmp %eax,0x10(%ebp) <== NOT EXECUTED 109fbf: 0f 82 a0 00 00 00 jb 10a065 <_Heap_Initialize+0x105> <== NOT EXECUTED return 0; /* Too small area for the heap */ the_size = size - overhead; 109fc5: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 109fc8: 29 c2 sub %eax,%edx <== NOT EXECUTED 109fca: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED * * @return free block information filled in. */ bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info 109fcd: 89 d0 mov %edx,%eax <== NOT EXECUTED 109fcf: 31 d2 xor %edx,%edx <== NOT EXECUTED 109fd1: f7 f1 div %ecx <== NOT EXECUTED _Heap_Align_down ( &the_size, page_size ); if ( the_size == 0 ) 109fd3: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 109fd6: 29 d0 sub %edx,%eax <== NOT EXECUTED 109fd8: 89 c2 mov %eax,%edx <== NOT EXECUTED 109fda: 0f 84 85 00 00 00 je 10a065 <_Heap_Initialize+0x105> <== NOT EXECUTED return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 109fe0: 89 4e 10 mov %ecx,0x10(%esi) <== NOT EXECUTED the_heap->begin = starting_address; 109fe3: 89 7e 18 mov %edi,0x18(%esi) <== NOT EXECUTED the_heap->end = starting_address + size; 109fe6: 03 7d 10 add 0x10(%ebp),%edi <== NOT EXECUTED 109fe9: 89 7e 1c mov %edi,0x1c(%esi) <== NOT EXECUTED the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; 109fec: 89 0b mov %ecx,(%ebx) <== NOT EXECUTED the_block->size = the_size | HEAP_PREV_USED; 109fee: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 109ff1: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED the_block->next = _Heap_Tail( the_heap ); 109ff4: 89 73 08 mov %esi,0x8(%ebx) <== NOT EXECUTED the_block->prev = _Heap_Head( the_heap ); 109ff7: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED _Heap_Head(the_heap)->next = the_block; 109ffa: 89 5e 08 mov %ebx,0x8(%esi) <== NOT EXECUTED _Heap_Tail(the_heap)->prev = the_block; 109ffd: 89 5e 0c mov %ebx,0xc(%esi) <== NOT EXECUTED the_heap->start = the_block; 10a000: 89 5e 20 mov %ebx,0x20(%esi) <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 10a003: 8d 04 13 lea (%ebx,%edx,1),%eax <== NOT EXECUTED _HAssert(_Heap_Is_aligned(the_heap->page_size, CPU_ALIGNMENT)); _HAssert(_Heap_Is_aligned(the_heap->min_block_size, page_size)); _HAssert(_Heap_Is_aligned_ptr(_Heap_User_area(the_block), page_size)); the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ 10a006: 89 46 24 mov %eax,0x24(%esi) <== NOT EXECUTED the_block->prev_size = the_size; /* Previous block is free */ 10a009: 89 10 mov %edx,(%eax) <== NOT EXECUTED the_block->size = page_size; 10a00b: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED stats->size = size; 10a00e: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10a011: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED stats->free_size = the_size; 10a014: 89 56 30 mov %edx,0x30(%esi) <== NOT EXECUTED stats->min_free_size = the_size; 10a017: 89 56 34 mov %edx,0x34(%esi) <== NOT EXECUTED stats->free_blocks = 1; 10a01a: c7 46 38 01 00 00 00 movl $0x1,0x38(%esi) <== NOT EXECUTED stats->max_free_blocks = 1; 10a021: c7 46 3c 01 00 00 00 movl $0x1,0x3c(%esi) <== NOT EXECUTED stats->used_blocks = 0; 10a028: c7 46 40 00 00 00 00 movl $0x0,0x40(%esi) <== NOT EXECUTED stats->max_search = 0; 10a02f: c7 46 44 00 00 00 00 movl $0x0,0x44(%esi) <== NOT EXECUTED stats->allocs = 0; 10a036: c7 46 48 00 00 00 00 movl $0x0,0x48(%esi) <== NOT EXECUTED stats->searches = 0; 10a03d: c7 46 4c 00 00 00 00 movl $0x0,0x4c(%esi) <== NOT EXECUTED stats->frees = 0; 10a044: c7 46 50 00 00 00 00 movl $0x0,0x50(%esi) <== NOT EXECUTED stats->resizes = 0; 10a04b: c7 46 54 00 00 00 00 movl $0x0,0x54(%esi) <== NOT EXECUTED stats->instance = instance++; 10a052: a1 b4 c7 11 00 mov 0x11c7b4,%eax <== NOT EXECUTED 10a057: 89 46 28 mov %eax,0x28(%esi) <== NOT EXECUTED 10a05a: 40 inc %eax <== NOT EXECUTED 10a05b: a3 b4 c7 11 00 mov %eax,0x11c7b4 <== NOT EXECUTED return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 10a060: 8d 42 fc lea -0x4(%edx),%eax <== NOT EXECUTED 10a063: eb 02 jmp 10a067 <_Heap_Initialize+0x107> <== NOT EXECUTED 10a065: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10a067: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10a06a: 5b pop %ebx <== NOT EXECUTED 10a06b: 5e pop %esi <== NOT EXECUTED 10a06c: 5f pop %edi <== NOT EXECUTED 10a06d: c9 leave <== NOT EXECUTED 10a06e: c3 ret <== NOT EXECUTED 00114fe4 <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 114fe4: 55 push %ebp <== NOT EXECUTED 114fe5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114fe7: 57 push %edi <== NOT EXECUTED 114fe8: 56 push %esi <== NOT EXECUTED 114fe9: 53 push %ebx <== NOT EXECUTED 114fea: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED Heap_Block *next_next_block; uint32_t old_block_size; uint32_t old_user_size; uint32_t prev_used_flag; Heap_Statistics *const stats = &the_heap->stats; uint32_t const min_block_size = the_heap->min_block_size; 114fed: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 114ff0: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 114ff3: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED uint32_t const page_size = the_heap->page_size; 114ff6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 114ff9: 8b 72 10 mov 0x10(%edx),%esi <== NOT EXECUTED *old_mem_size = 0; 114ffc: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 114fff: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED *avail_mem_size = 0; 115005: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 115008: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 11500e: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 115011: 83 ea 08 sub $0x8,%edx <== NOT EXECUTED 115014: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 115017: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11501a: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 11501d: 31 d2 xor %edx,%edx <== NOT EXECUTED 11501f: f7 71 10 divl 0x10(%ecx) <== NOT EXECUTED 115022: 29 55 f0 sub %edx,-0x10(%ebp) <== NOT EXECUTED 115025: 89 c8 mov %ecx,%eax <== NOT EXECUTED 115027: 8b 49 24 mov 0x24(%ecx),%ecx <== NOT EXECUTED 11502a: 8b 58 20 mov 0x20(%eax),%ebx <== NOT EXECUTED _Heap_Start_of_block(the_heap, starting_address, &the_block); _HAssert(_Heap_Is_block_in(the_heap, the_block)); if (!_Heap_Is_block_in(the_heap, the_block)) 11502d: 39 5d f0 cmp %ebx,-0x10(%ebp) <== NOT EXECUTED 115030: 0f 93 c2 setae %dl <== NOT EXECUTED 115033: 39 4d f0 cmp %ecx,-0x10(%ebp) <== NOT EXECUTED 115036: 0f 96 c0 setbe %al <== NOT EXECUTED 115039: 84 d0 test %dl,%al <== NOT EXECUTED 11503b: 0f 84 7e 01 00 00 je 1151bf <_Heap_Resize_block+0x1db> <== NOT EXECUTED return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 115041: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 115044: 8b 52 04 mov 0x4(%edx),%edx <== NOT EXECUTED 115047: 89 55 d8 mov %edx,-0x28(%ebp) <== NOT EXECUTED 11504a: 83 e2 fe and $0xfffffffe,%edx <== NOT EXECUTED 11504d: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED 115050: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 115053: 01 d7 add %edx,%edi <== NOT EXECUTED old_block_size = _Heap_Block_size(the_block); next_block = _Heap_Block_at(the_block, old_block_size); _HAssert(_Heap_Is_block_in(the_heap, next_block)); _HAssert(_Heap_Is_prev_used(next_block)); if ( !_Heap_Is_block_in(the_heap, next_block) || 115055: 39 df cmp %ebx,%edi <== NOT EXECUTED 115057: 0f 93 c2 setae %dl <== NOT EXECUTED 11505a: 39 cf cmp %ecx,%edi <== NOT EXECUTED 11505c: 0f 96 c0 setbe %al <== NOT EXECUTED 11505f: 84 d0 test %dl,%al <== NOT EXECUTED 115061: 0f 84 58 01 00 00 je 1151bf <_Heap_Resize_block+0x1db> <== NOT EXECUTED 115067: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 11506a: a8 01 test $0x1,%al <== NOT EXECUTED 11506c: 0f 84 4d 01 00 00 je 1151bf <_Heap_Resize_block+0x1db> <== NOT EXECUTED 115072: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 115075: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED 115078: 01 f8 add %edi,%eax <== NOT EXECUTED 11507a: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED !_Heap_Is_prev_used(next_block)) return HEAP_RESIZE_FATAL_ERROR; next_block_size = _Heap_Block_size(next_block); next_next_block = _Heap_Block_at(next_block, next_block_size); next_is_used = (next_block == the_heap->final) || 11507d: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 115082: 39 cf cmp %ecx,%edi <== NOT EXECUTED 115084: 74 09 je 11508f <_Heap_Resize_block+0xab> <== NOT EXECUTED 115086: 8b 4d e0 mov -0x20(%ebp),%ecx <== NOT EXECUTED 115089: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 11508c: 83 e0 01 and $0x1,%eax <== NOT EXECUTED _Heap_Start_of_block(the_heap, starting_address, &the_block); _HAssert(_Heap_Is_block_in(the_heap, the_block)); if (!_Heap_Is_block_in(the_heap, the_block)) return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 11508f: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 115092: 83 e2 01 and $0x1,%edx <== NOT EXECUTED 115095: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED !_Heap_Is_prev_used(next_block)) return HEAP_RESIZE_FATAL_ERROR; next_block_size = _Heap_Block_size(next_block); next_next_block = _Heap_Block_at(next_block, next_block_size); next_is_used = (next_block == the_heap->final) || 115098: 88 c1 mov %al,%cl <== NOT EXECUTED _Heap_Is_prev_used(next_next_block); /* See _Heap_Size_of_user_area() source for explanations */ old_user_size = _Addresses_Subtract(next_block, starting_address) 11509a: 89 f8 mov %edi,%eax <== NOT EXECUTED 11509c: 2b 45 0c sub 0xc(%ebp),%eax <== NOT EXECUTED 11509f: 83 c0 04 add $0x4,%eax <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 1150a2: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 1150a5: 89 02 mov %eax,(%edx) <== NOT EXECUTED if (size > old_user_size) { 1150a7: 39 45 10 cmp %eax,0x10(%ebp) <== NOT EXECUTED 1150aa: 76 50 jbe 1150fc <_Heap_Resize_block+0x118> <== NOT EXECUTED /* Need to extend the block: allocate part of the next block and then merge 'the_block' and allocated block together. */ if (next_is_used) /* Next block is in use, -- no way to extend */ 1150ac: 84 c9 test %cl,%cl <== NOT EXECUTED 1150ae: 0f 85 12 01 00 00 jne 1151c6 <_Heap_Resize_block+0x1e2> <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; else { uint32_t add_block_size = size - old_user_size; 1150b4: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 1150b7: 29 c1 sub %eax,%ecx <== NOT EXECUTED * sizes. * * @param[in] the_heap pointer to heap header * @param[in] the_info pointer to a status information area * * @return true if successfully able to return information 1150b9: 89 c8 mov %ecx,%eax <== NOT EXECUTED 1150bb: 31 d2 xor %edx,%edx <== NOT EXECUTED 1150bd: f7 f6 div %esi <== NOT EXECUTED */ 1150bf: 85 d2 test %edx,%edx <== NOT EXECUTED 1150c1: 74 04 je 1150c7 <_Heap_Resize_block+0xe3> <== NOT EXECUTED 1150c3: 01 f1 add %esi,%ecx <== NOT EXECUTED 1150c5: 29 d1 sub %edx,%ecx <== NOT EXECUTED 1150c7: 89 c8 mov %ecx,%eax <== NOT EXECUTED 1150c9: 3b 4d ec cmp -0x14(%ebp),%ecx <== NOT EXECUTED 1150cc: 73 03 jae 1150d1 <_Heap_Resize_block+0xed> <== NOT EXECUTED 1150ce: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED _Heap_Align_up(&add_block_size, page_size); if (add_block_size < min_block_size) add_block_size = min_block_size; if (add_block_size > next_block_size) 1150d1: 3b 45 dc cmp -0x24(%ebp),%eax <== NOT EXECUTED 1150d4: 0f 87 ec 00 00 00 ja 1151c6 <_Heap_Resize_block+0x1e2> <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */ add_block_size = 1150da: 53 push %ebx <== NOT EXECUTED 1150db: 50 push %eax <== NOT EXECUTED 1150dc: 57 push %edi <== NOT EXECUTED 1150dd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1150e0: e8 c7 4f ff ff call 10a0ac <_Heap_Block_allocate> <== NOT EXECUTED _Heap_Block_allocate(the_heap, next_block, add_block_size); /* Merge two subsequent blocks */ the_block->size = (old_block_size + add_block_size) | prev_used_flag; 1150e5: 03 45 e4 add -0x1c(%ebp),%eax <== NOT EXECUTED 1150e8: 0b 45 e8 or -0x18(%ebp),%eax <== NOT EXECUTED 1150eb: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 1150ee: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED --stats->used_blocks; 1150f1: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1150f4: ff 49 40 decl 0x40(%ecx) <== NOT EXECUTED 1150f7: e9 b6 00 00 00 jmp 1151b2 <_Heap_Resize_block+0x1ce> <== NOT EXECUTED } } else { /* Calculate how much memory we could free */ uint32_t free_block_size = old_user_size - size; 1150fc: 89 c3 mov %eax,%ebx <== NOT EXECUTED 1150fe: 2b 5d 10 sub 0x10(%ebp),%ebx <== NOT EXECUTED * * @return free block information filled in. */ bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info 115101: 89 d8 mov %ebx,%eax <== NOT EXECUTED 115103: 31 d2 xor %edx,%edx <== NOT EXECUTED 115105: f7 f6 div %esi <== NOT EXECUTED _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 115107: 89 de mov %ebx,%esi <== NOT EXECUTED 115109: 29 d6 sub %edx,%esi <== NOT EXECUTED 11510b: 0f 84 a4 00 00 00 je 1151b5 <_Heap_Resize_block+0x1d1> <== NOT EXECUTED /* To free some memory the block should be shortened so that it can can hold 'size' user bytes and still remain not shorter than 'min_block_size'. */ uint32_t new_block_size = old_block_size - free_block_size; 115111: 8b 5d e4 mov -0x1c(%ebp),%ebx <== NOT EXECUTED 115114: 29 f3 sub %esi,%ebx <== NOT EXECUTED if (new_block_size < min_block_size) { 115116: 3b 5d ec cmp -0x14(%ebp),%ebx <== NOT EXECUTED 115119: 73 16 jae 115131 <_Heap_Resize_block+0x14d> <== NOT EXECUTED uint32_t delta = min_block_size - new_block_size; 11511b: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11511e: 29 d8 sub %ebx,%eax <== NOT EXECUTED _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 115120: 29 c6 sub %eax,%esi <== NOT EXECUTED 115122: 75 0b jne 11512f <_Heap_Resize_block+0x14b> <== NOT EXECUTED ++stats->resizes; 115124: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 115127: ff 42 54 incl 0x54(%edx) <== NOT EXECUTED 11512a: e9 8c 00 00 00 jmp 1151bb <_Heap_Resize_block+0x1d7> <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; } new_block_size += delta; 11512f: 01 c3 add %eax,%ebx <== NOT EXECUTED _HAssert(new_block_size >= min_block_size); _HAssert(new_block_size + free_block_size == old_block_size); _HAssert(_Heap_Is_aligned(new_block_size, page_size)); _HAssert(_Heap_Is_aligned(free_block_size, page_size)); if (!next_is_used) { 115131: 84 c9 test %cl,%cl <== NOT EXECUTED 115133: 75 43 jne 115178 <_Heap_Resize_block+0x194> <== NOT EXECUTED 115135: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 115138: 01 da add %ebx,%edx <== NOT EXECUTED /* Extend the next block to the low addresses by 'free_block_size' */ Heap_Block *const new_next_block = _Heap_Block_at(the_block, new_block_size); uint32_t const new_next_block_size = next_block_size + free_block_size; 11513a: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 11513d: 8d 0c 06 lea (%esi,%eax,1),%ecx <== NOT EXECUTED _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; 115140: 0b 5d e8 or -0x18(%ebp),%ebx <== NOT EXECUTED 115143: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 115146: 89 58 04 mov %ebx,0x4(%eax) <== NOT EXECUTED new_next_block->size = new_next_block_size | HEAP_PREV_USED; 115149: 89 c8 mov %ecx,%eax <== NOT EXECUTED 11514b: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 11514e: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED next_next_block->prev_size = new_next_block_size; 115151: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 115154: 89 08 mov %ecx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ 115156: 8b 5f 08 mov 0x8(%edi),%ebx <== NOT EXECUTED bool _Protected_heap_Get_block_size( 115159: 8b 47 0c mov 0xc(%edi),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size 11515c: 89 5a 08 mov %ebx,0x8(%edx) <== NOT EXECUTED ); 11515f: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED 115162: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED 115165: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED _Heap_Block_replace(next_block, new_next_block); the_heap->stats.free_size += free_block_size; 115168: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 11516b: 01 72 30 add %esi,0x30(%edx) <== NOT EXECUTED *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 11516e: 83 e9 04 sub $0x4,%ecx <== NOT EXECUTED 115171: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 115174: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 115176: eb 3d jmp 1151b5 <_Heap_Resize_block+0x1d1> <== NOT EXECUTED } else if (free_block_size >= min_block_size) { 115178: 3b 75 ec cmp -0x14(%ebp),%esi <== NOT EXECUTED 11517b: 72 38 jb 1151b5 <_Heap_Resize_block+0x1d1> <== NOT EXECUTED /* Split the block into 2 used parts, then free the second one. */ the_block->size = new_block_size | prev_used_flag; 11517d: 09 5d e8 or %ebx,-0x18(%ebp) <== NOT EXECUTED 115180: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 115183: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 115186: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED 115189: 89 d0 mov %edx,%eax <== NOT EXECUTED 11518b: 01 d8 add %ebx,%eax <== NOT EXECUTED next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; 11518d: 89 f2 mov %esi,%edx <== NOT EXECUTED 11518f: 83 ca 01 or $0x1,%edx <== NOT EXECUTED 115192: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 115195: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 115198: ff 42 40 incl 0x40(%edx) <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 11519b: ff 4a 50 decl 0x50(%edx) <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 11519e: 51 push %ecx <== NOT EXECUTED 11519f: 51 push %ecx <== NOT EXECUTED 1151a0: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 1151a3: 50 push %eax <== NOT EXECUTED 1151a4: 52 push %edx <== NOT EXECUTED 1151a5: e8 5e 87 ff ff call 10d908 <_Heap_Free> <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 1151aa: 8d 46 fc lea -0x4(%esi),%eax <== NOT EXECUTED 1151ad: 8b 4d 18 mov 0x18(%ebp),%ecx <== NOT EXECUTED 1151b0: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 1151b2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } } ++stats->resizes; 1151b5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1151b8: ff 40 54 incl 0x54(%eax) <== NOT EXECUTED 1151bb: 31 c0 xor %eax,%eax <== NOT EXECUTED 1151bd: eb 0c jmp 1151cb <_Heap_Resize_block+0x1e7> <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; 1151bf: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 1151c4: eb 05 jmp 1151cb <_Heap_Resize_block+0x1e7> <== NOT EXECUTED 1151c6: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED } 1151cb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1151ce: 5b pop %ebx <== NOT EXECUTED 1151cf: 5e pop %esi <== NOT EXECUTED 1151d0: 5f pop %edi <== NOT EXECUTED 1151d1: c9 leave <== NOT EXECUTED 1151d2: c3 ret <== NOT EXECUTED 001151d4 <_Heap_Size_of_user_area>: bool _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 1151d4: 55 push %ebp <== NOT EXECUTED 1151d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1151d7: 57 push %edi <== NOT EXECUTED 1151d8: 56 push %esi <== NOT EXECUTED 1151d9: 53 push %ebx <== NOT EXECUTED 1151da: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Heap_Block *the_block; Heap_Block *next_block; uint32_t the_size; if ( !_Addresses_Is_in_range( 1151dd: 8b 7e 24 mov 0x24(%esi),%edi <== NOT EXECUTED 1151e0: 8b 5e 20 mov 0x20(%esi),%ebx <== NOT EXECUTED 1151e3: 39 5d 0c cmp %ebx,0xc(%ebp) <== NOT EXECUTED 1151e6: 0f 93 c2 setae %dl <== NOT EXECUTED 1151e9: 39 7d 0c cmp %edi,0xc(%ebp) <== NOT EXECUTED 1151ec: 0f 96 c0 setbe %al <== NOT EXECUTED 1151ef: 84 d0 test %dl,%al <== NOT EXECUTED 1151f1: 74 49 je 11523c <_Heap_Size_of_user_area+0x68> <== NOT EXECUTED 1151f3: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1151f6: 83 e9 08 sub $0x8,%ecx <== NOT EXECUTED 1151f9: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1151fc: 31 d2 xor %edx,%edx <== NOT EXECUTED 1151fe: f7 76 10 divl 0x10(%esi) <== NOT EXECUTED 115201: 29 d1 sub %edx,%ecx <== NOT EXECUTED return( FALSE ); _Heap_Start_of_block( the_heap, starting_address, &the_block ); _HAssert(_Heap_Is_block_in( the_heap, the_block )); if ( !_Heap_Is_block_in( the_heap, the_block ) ) 115203: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 115205: 0f 93 c2 setae %dl <== NOT EXECUTED 115208: 39 f9 cmp %edi,%ecx <== NOT EXECUTED 11520a: 0f 96 c0 setbe %al <== NOT EXECUTED 11520d: 84 d0 test %dl,%al <== NOT EXECUTED 11520f: 74 2b je 11523c <_Heap_Size_of_user_area+0x68> <== NOT EXECUTED 115211: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 115214: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 115217: 01 c1 add %eax,%ecx <== NOT EXECUTED the_size = _Heap_Block_size( the_block ); next_block = _Heap_Block_at( the_block, the_size ); _HAssert(_Heap_Is_block_in( the_heap, next_block )); _HAssert(_Heap_Is_prev_used( next_block )); if ( 115219: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 11521b: 0f 93 c2 setae %dl <== NOT EXECUTED 11521e: 39 f9 cmp %edi,%ecx <== NOT EXECUTED 115220: 0f 96 c0 setbe %al <== NOT EXECUTED 115223: 84 d0 test %dl,%al <== NOT EXECUTED 115225: 74 15 je 11523c <_Heap_Size_of_user_area+0x68> <== NOT EXECUTED 115227: f6 41 04 01 testb $0x1,0x4(%ecx) <== NOT EXECUTED 11522b: 74 0f je 11523c <_Heap_Size_of_user_area+0x68> <== NOT EXECUTED and then add correction equal to the offset of the 'size' field of the 'Heap_Block' structure. The correction is due to the fact that 'prev_size' field of the next block is actually used as user accessible area of 'the_block'. */ *size = _Addresses_Subtract ( next_block, starting_address ) 11522d: 2b 4d 0c sub 0xc(%ebp),%ecx <== NOT EXECUTED 115230: 8d 51 04 lea 0x4(%ecx),%edx <== NOT EXECUTED 115233: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 115236: 89 10 mov %edx,(%eax) <== NOT EXECUTED 115238: b0 01 mov $0x1,%al <== NOT EXECUTED 11523a: eb 02 jmp 11523e <_Heap_Size_of_user_area+0x6a> <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; return( TRUE ); 11523c: 31 c0 xor %eax,%eax <== NOT EXECUTED } 11523e: 5b pop %ebx <== NOT EXECUTED 11523f: 5e pop %esi <== NOT EXECUTED 115240: 5f pop %edi <== NOT EXECUTED 115241: c9 leave <== NOT EXECUTED 115242: c3 ret <== NOT EXECUTED 0010fa2c <_Heap_Walk>: bool _Heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 10fa2c: 55 push %ebp <== NOT EXECUTED 10fa2d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fa2f: 57 push %edi <== NOT EXECUTED 10fa30: 56 push %esi <== NOT EXECUTED 10fa31: 53 push %ebx <== NOT EXECUTED 10fa32: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10fa35: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Heap_Block *the_block = the_heap->start; 10fa38: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10fa3b: 8b 70 20 mov 0x20(%eax),%esi <== NOT EXECUTED Heap_Block *const end = the_heap->final; 10fa3e: 8b 50 24 mov 0x24(%eax),%edx <== NOT EXECUTED 10fa41: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED /* if ( !_System_state_Is_up( _System_state_Get() ) ) return TRUE; */ if (source < 0) 10fa44: 85 db test %ebx,%ebx <== NOT EXECUTED 10fa46: 79 03 jns 10fa4b <_Heap_Walk+0x1f> <== NOT EXECUTED source = the_heap->stats.instance; 10fa48: 8b 58 28 mov 0x28(%eax),%ebx <== NOT EXECUTED /* * Handle the 1st block */ if (!_Heap_Is_prev_used(the_block)) { 10fa4b: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10fa4d: f6 46 04 01 testb $0x1,0x4(%esi) <== NOT EXECUTED 10fa51: 75 15 jne 10fa68 <_Heap_Walk+0x3c> <== NOT EXECUTED printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source); 10fa53: 50 push %eax <== NOT EXECUTED 10fa54: 50 push %eax <== NOT EXECUTED 10fa55: 53 push %ebx <== NOT EXECUTED 10fa56: 68 38 aa 11 00 push $0x11aa38 <== NOT EXECUTED 10fa5b: e8 4a 8a ff ff call 1084aa <== NOT EXECUTED 10fa60: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 10fa65: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } if (the_block->prev_size != the_heap->page_size) { 10fa68: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10fa6a: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10fa6d: 3b 47 10 cmp 0x10(%edi),%eax <== NOT EXECUTED 10fa70: 0f 84 38 01 00 00 je 10fbae <_Heap_Walk+0x182> <== NOT EXECUTED printk("PASS: %d !prev_size of 1st block isn't page_size\n", source); 10fa76: 50 push %eax <== NOT EXECUTED 10fa77: 50 push %eax <== NOT EXECUTED 10fa78: 53 push %ebx <== NOT EXECUTED 10fa79: 68 6e aa 11 00 push $0x11aa6e <== NOT EXECUTED 10fa7e: e8 27 8a ff ff call 1084aa <== NOT EXECUTED 10fa83: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 10fa88: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fa8b: e9 1e 01 00 00 jmp 10fbae <_Heap_Walk+0x182> <== NOT EXECUTED 10fa90: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10fa93: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 10fa96: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 10fa99: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED /** @brief _Thread_Is_proxy_blocking * * status which indicates that a proxy is blocking, and FALSE otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking ( uint32_t code 10fa9c: 01 f0 add %esi,%eax <== NOT EXECUTED 10fa9e: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED printk(" prev_size %d", the_block->prev_size); else printk(" (prev_size) %d", the_block->prev_size); } if (!_Heap_Is_block_in(the_heap, next_block)) { 10faa1: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10faa4: 3b 42 20 cmp 0x20(%edx),%eax <== NOT EXECUTED 10faa7: 0f 93 c2 setae %dl <== NOT EXECUTED 10faaa: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10faad: 3b 47 24 cmp 0x24(%edi),%eax <== NOT EXECUTED 10fab0: 0f 96 c0 setbe %al <== NOT EXECUTED 10fab3: 84 d0 test %dl,%al <== NOT EXECUTED 10fab5: 75 0f jne 10fac6 <_Heap_Walk+0x9a> <== NOT EXECUTED if (do_dump) printk("\n"); printk("PASS: %d !block %p is out of heap\n", source, next_block); 10fab7: 50 push %eax <== NOT EXECUTED 10fab8: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10fabb: 53 push %ebx <== NOT EXECUTED 10fabc: 68 a0 aa 11 00 push $0x11aaa0 <== NOT EXECUTED 10fac1: e9 d7 00 00 00 jmp 10fb9d <_Heap_Walk+0x171> <== NOT EXECUTED error = 1; break; } if (!_Heap_Is_prev_used(next_block)) { 10fac6: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10fac9: f6 40 04 01 testb $0x1,0x4(%eax) <== NOT EXECUTED 10facd: 0f 85 85 00 00 00 jne 10fb58 <_Heap_Walk+0x12c> <== NOT EXECUTED if (do_dump) printk( " prev %p next %p", the_block->prev, the_block->next); if (_Heap_Block_size(the_block) != next_block->prev_size) { 10fad3: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10fad6: 3b 10 cmp (%eax),%edx <== NOT EXECUTED 10fad8: 74 15 je 10faef <_Heap_Walk+0xc3> <== NOT EXECUTED if (do_dump) printk("\n"); printk("PASS: %d !front and back sizes don't match", source); 10fada: 50 push %eax <== NOT EXECUTED 10fadb: 50 push %eax <== NOT EXECUTED 10fadc: 53 push %ebx <== NOT EXECUTED 10fadd: 68 c3 aa 11 00 push $0x11aac3 <== NOT EXECUTED 10fae2: e8 c3 89 ff ff call 1084aa <== NOT EXECUTED 10fae7: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 10faec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } if (!prev_used) { 10faef: f6 45 f0 01 testb $0x1,-0x10(%ebp) <== NOT EXECUTED 10faf3: 75 29 jne 10fb1e <_Heap_Walk+0xf2> <== NOT EXECUTED if (do_dump || error) printk("\n"); 10faf5: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10faf7: 74 10 je 10fb09 <_Heap_Walk+0xdd> <== NOT EXECUTED 10faf9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fafc: 68 ad a7 11 00 push $0x11a7ad <== NOT EXECUTED 10fb01: e8 a4 89 ff ff call 1084aa <== NOT EXECUTED 10fb06: 83 c4 10 add $0x10,%esp <== NOT EXECUTED printk("PASS: %d !two consecutive blocks are free", source); 10fb09: 57 push %edi <== NOT EXECUTED 10fb0a: 57 push %edi <== NOT EXECUTED 10fb0b: 53 push %ebx <== NOT EXECUTED 10fb0c: 68 ee aa 11 00 push $0x11aaee <== NOT EXECUTED 10fb11: e8 94 89 ff ff call 1084aa <== NOT EXECUTED 10fb16: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 10fb1b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { return ( the_thread == _Thread_Heir ); } /** 10fb1e: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10fb21: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED 10fb24: eb 03 jmp 10fb29 <_Heap_Walk+0xfd> <== NOT EXECUTED } { /* Check if 'the_block' is in the free block list */ Heap_Block* block = _Heap_First(the_heap); while(block != the_block && block != tail) block = block->next; 10fb26: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED error = 1; } { /* Check if 'the_block' is in the free block list */ Heap_Block* block = _Heap_First(the_heap); while(block != the_block && block != tail) 10fb29: 39 f0 cmp %esi,%eax <== NOT EXECUTED 10fb2b: 74 2b je 10fb58 <_Heap_Walk+0x12c> <== NOT EXECUTED 10fb2d: 3b 45 08 cmp 0x8(%ebp),%eax <== NOT EXECUTED 10fb30: 75 f4 jne 10fb26 <_Heap_Walk+0xfa> <== NOT EXECUTED block = block->next; if(block != the_block) { if (do_dump || error) printk("\n"); 10fb32: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10fb34: 74 10 je 10fb46 <_Heap_Walk+0x11a> <== NOT EXECUTED 10fb36: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fb39: 68 ad a7 11 00 push $0x11a7ad <== NOT EXECUTED 10fb3e: e8 67 89 ff ff call 1084aa <== NOT EXECUTED 10fb43: 83 c4 10 add $0x10,%esp <== NOT EXECUTED printk("PASS: %d !the_block not in the free list", source); 10fb46: 51 push %ecx <== NOT EXECUTED 10fb47: 51 push %ecx <== NOT EXECUTED 10fb48: 53 push %ebx <== NOT EXECUTED 10fb49: 68 18 ab 11 00 push $0x11ab18 <== NOT EXECUTED 10fb4e: e8 57 89 ff ff call 1084aa <== NOT EXECUTED 10fb53: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fb56: eb 04 jmp 10fb5c <_Heap_Walk+0x130> <== NOT EXECUTED error = 1; } } } if (do_dump || error) printk("\n"); 10fb58: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10fb5a: 74 15 je 10fb71 <_Heap_Walk+0x145> <== NOT EXECUTED 10fb5c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fb5f: 68 ad a7 11 00 push $0x11a7ad <== NOT EXECUTED 10fb64: e8 41 89 ff ff call 1084aa <== NOT EXECUTED 10fb69: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 10fb6e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (the_size < the_heap->min_block_size) { 10fb71: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10fb74: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10fb77: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10fb7a: 73 0a jae 10fb86 <_Heap_Walk+0x15a> <== NOT EXECUTED printk("PASS: %d !block size is too small\n", source); 10fb7c: 52 push %edx <== NOT EXECUTED 10fb7d: 52 push %edx <== NOT EXECUTED 10fb7e: 53 push %ebx <== NOT EXECUTED 10fb7f: 68 41 ab 11 00 push $0x11ab41 <== NOT EXECUTED 10fb84: eb 17 jmp 10fb9d <_Heap_Walk+0x171> <== NOT EXECUTED error = 1; break; } if (!_Heap_Is_aligned( the_size, the_heap->page_size)) { 10fb86: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10fb89: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10fb8c: 31 d2 xor %edx,%edx <== NOT EXECUTED 10fb8e: f7 77 10 divl 0x10(%edi) <== NOT EXECUTED 10fb91: 85 d2 test %edx,%edx <== NOT EXECUTED 10fb93: 74 12 je 10fba7 <_Heap_Walk+0x17b> <== NOT EXECUTED printk("PASS: %d !block size is misaligned\n", source); 10fb95: 50 push %eax <== NOT EXECUTED 10fb96: 50 push %eax <== NOT EXECUTED 10fb97: 53 push %ebx <== NOT EXECUTED 10fb98: 68 64 ab 11 00 push $0x11ab64 <== NOT EXECUTED 10fb9d: e8 08 89 ff ff call 1084aa <== NOT EXECUTED 10fba2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fba5: eb 12 jmp 10fbb9 <_Heap_Walk+0x18d> <== NOT EXECUTED error = 1; } if (++passes > (do_dump ? 10 : 0) && error) 10fba7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10fba9: 75 0e jne 10fbb9 <_Heap_Walk+0x18d> <== NOT EXECUTED break; 10fbab: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED if (the_block->prev_size != the_heap->page_size) { printk("PASS: %d !prev_size of 1st block isn't page_size\n", source); error = 1; } while ( the_block != end ) { 10fbae: 3b 75 e8 cmp -0x18(%ebp),%esi <== NOT EXECUTED 10fbb1: 0f 85 d9 fe ff ff jne 10fa90 <_Heap_Walk+0x64> <== NOT EXECUTED 10fbb7: eb 17 jmp 10fbd0 <_Heap_Walk+0x1a4> <== NOT EXECUTED the_block = next_block; } if (the_block != end) { printk("PASS: %d !last block address isn't equal to 'final' %p %p\n", 10fbb9: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 10fbbc: 56 push %esi <== NOT EXECUTED 10fbbd: 53 push %ebx <== NOT EXECUTED 10fbbe: 68 88 ab 11 00 push $0x11ab88 <== NOT EXECUTED 10fbc3: e8 e2 88 ff ff call 1084aa <== NOT EXECUTED 10fbc8: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 10fbcd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fbd0: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10fbd3: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED source, the_block, end); error = 1; } if (_Heap_Block_size(the_block) != the_heap->page_size) { 10fbd6: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10fbd9: 8b 56 10 mov 0x10(%esi),%edx <== NOT EXECUTED 10fbdc: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10fbde: 74 15 je 10fbf5 <_Heap_Walk+0x1c9> <== NOT EXECUTED printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source, 10fbe0: 52 push %edx <== NOT EXECUTED 10fbe1: 50 push %eax <== NOT EXECUTED 10fbe2: 53 push %ebx <== NOT EXECUTED 10fbe3: 68 c3 ab 11 00 push $0x11abc3 <== NOT EXECUTED 10fbe8: e8 bd 88 ff ff call 1084aa <== NOT EXECUTED 10fbed: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 10fbf2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fbf5: 88 c8 mov %cl,%al <== NOT EXECUTED if(do_dump && error) _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 ); return error; } 10fbf7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fbfa: 5b pop %ebx <== NOT EXECUTED 10fbfb: 5e pop %esi <== NOT EXECUTED 10fbfc: 5f pop %edi <== NOT EXECUTED 10fbfd: c9 leave <== NOT EXECUTED 10fbfe: c3 ret <== NOT EXECUTED 00109774 <_IO_Initialize_all_drivers>: * * Output Parameters: NONE */ void _IO_Initialize_all_drivers( void ) { 109774: 55 push %ebp <== NOT EXECUTED 109775: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109777: 53 push %ebx <== NOT EXECUTED 109778: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10977b: 31 db xor %ebx,%ebx <== NOT EXECUTED 10977d: eb 0f jmp 10978e <_IO_Initialize_all_drivers+0x1a> <== NOT EXECUTED rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) (void) rtems_io_initialize( major, 0, NULL ); 10977f: 50 push %eax <== NOT EXECUTED 109780: 6a 00 push $0x0 <== NOT EXECUTED 109782: 6a 00 push $0x0 <== NOT EXECUTED 109784: 53 push %ebx <== NOT EXECUTED 109785: e8 86 3e 00 00 call 10d610 <== NOT EXECUTED void _IO_Initialize_all_drivers( void ) { rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10978a: 43 inc %ebx <== NOT EXECUTED 10978b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10978e: 3b 1d 2c cd 11 00 cmp 0x11cd2c,%ebx <== NOT EXECUTED 109794: 72 e9 jb 10977f <_IO_Initialize_all_drivers+0xb> <== NOT EXECUTED (void) rtems_io_initialize( major, 0, NULL ); } 109796: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109799: c9 leave <== NOT EXECUTED 10979a: c3 ret <== NOT EXECUTED 0010979b <_IO_Manager_initialization>: void _IO_Manager_initialization( rtems_driver_address_table *driver_table, uint32_t drivers_in_table, uint32_t number_of_drivers ) { 10979b: 55 push %ebp <== NOT EXECUTED 10979c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10979e: 57 push %edi <== NOT EXECUTED 10979f: 56 push %esi <== NOT EXECUTED 1097a0: 53 push %ebx <== NOT EXECUTED 1097a1: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1097a4: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED /* * 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 ) 1097a7: 3b 75 0c cmp 0xc(%ebp),%esi <== NOT EXECUTED 1097aa: 76 2f jbe 1097db <_IO_Manager_initialization+0x40> <== NOT EXECUTED /* * 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 *) 1097ac: 6b de 18 imul $0x18,%esi,%ebx <== NOT EXECUTED 1097af: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1097b2: 53 push %ebx <== NOT EXECUTED 1097b3: e8 ba 25 00 00 call 10bd72 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 1097b8: 89 c7 mov %eax,%edi <== NOT EXECUTED 1097ba: a3 30 cd 11 00 mov %eax,0x11cd30 <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; 1097bf: 89 35 2c cd 11 00 mov %esi,0x11cd2c <== NOT EXECUTED memset( 1097c5: 31 c0 xor %eax,%eax <== NOT EXECUTED 1097c7: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 1097c9: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 1097cb: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1097ce: 8b 15 30 cd 11 00 mov 0x11cd30,%edx <== NOT EXECUTED 1097d4: 31 c0 xor %eax,%eax <== NOT EXECUTED 1097d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1097d9: eb 25 jmp 109800 <_IO_Manager_initialization+0x65> <== NOT EXECUTED * 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; 1097db: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1097de: a3 30 cd 11 00 mov %eax,0x11cd30 <== NOT EXECUTED _IO_Number_of_drivers = number_of_drivers; 1097e3: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1097e6: 89 0d 2c cd 11 00 mov %ecx,0x11cd2c <== NOT EXECUTED 1097ec: eb 17 jmp 109805 <_IO_Manager_initialization+0x6a> <== NOT EXECUTED _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]; 1097ee: 89 d7 mov %edx,%edi <== NOT EXECUTED 1097f0: 89 de mov %ebx,%esi <== NOT EXECUTED 1097f2: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 1097f7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 1097f9: 40 inc %eax <== NOT EXECUTED 1097fa: 83 c3 18 add $0x18,%ebx <== NOT EXECUTED 1097fd: 83 c2 18 add $0x18,%edx <== NOT EXECUTED 109800: 3b 45 0c cmp 0xc(%ebp),%eax <== NOT EXECUTED 109803: 72 e9 jb 1097ee <_IO_Manager_initialization+0x53> <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; number_of_drivers = drivers_in_table; } 109805: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109808: 5b pop %ebx <== NOT EXECUTED 109809: 5e pop %esi <== NOT EXECUTED 10980a: 5f pop %edi <== NOT EXECUTED 10980b: c9 leave <== NOT EXECUTED 10980c: c3 ret <== NOT EXECUTED 0010a168 <_ISR_Handler_initialization>: * * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { 10a168: 55 push %ebp <== NOT EXECUTED 10a169: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a16b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED _ISR_Signals_to_thread_executing = FALSE; 10a16e: c6 05 54 cb 11 00 00 movb $0x0,0x11cb54 <== NOT EXECUTED _ISR_Nest_level = 0; 10a175: c7 05 9c ca 11 00 00 movl $0x0,0x11ca9c <== NOT EXECUTED 10a17c: 00 00 00 <== NOT EXECUTED _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( !_Stack_Is_enough(_Configuration_Table->interrupt_stack_size) ) 10a17f: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 10a184: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10a187: 3b 05 80 86 11 00 cmp 0x118680,%eax <== NOT EXECUTED 10a18d: 73 0c jae 10a19b <_ISR_Handler_initialization+0x33> <== NOT EXECUTED _Internal_error_Occurred( 10a18f: 50 push %eax <== NOT EXECUTED 10a190: 6a 05 push $0x5 <== NOT EXECUTED 10a192: 6a 01 push $0x1 <== NOT EXECUTED 10a194: 6a 00 push $0x0 <== NOT EXECUTED 10a196: e8 8d ff ff ff call 10a128 <_Internal_error_Occurred> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = _Workspace_Allocate_or_fatal_error( 10a19b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a19e: 50 push %eax <== NOT EXECUTED 10a19f: e8 ce 1b 00 00 call 10bd72 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10a1a4: a3 10 ca 11 00 mov %eax,0x11ca10 <== NOT EXECUTED _Configuration_Table->interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 10a1a9: 8b 15 98 ca 11 00 mov 0x11ca98,%edx <== NOT EXECUTED 10a1af: 03 42 1c add 0x1c(%edx),%eax <== NOT EXECUTED 10a1b2: a3 d0 c9 11 00 mov %eax,0x11c9d0 <== NOT EXECUTED 10a1b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE ) _CPU_Install_interrupt_stack(); #endif } 10a1ba: c9 leave <== NOT EXECUTED 10a1bb: c3 ret <== NOT EXECUTED 0010a128 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) { 10a128: 55 push %ebp <== NOT EXECUTED 10a129: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a12b: 53 push %ebx <== NOT EXECUTED 10a12c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a12f: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a132: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a135: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED _Internal_errors_What_happened.the_source = the_source; 10a138: 89 15 a8 ca 11 00 mov %edx,0x11caa8 <== NOT EXECUTED _Internal_errors_What_happened.is_internal = is_internal; 10a13e: a2 ac ca 11 00 mov %al,0x11caac <== NOT EXECUTED _Internal_errors_What_happened.the_error = the_error; 10a143: 89 1d b0 ca 11 00 mov %ebx,0x11cab0 <== NOT EXECUTED _User_extensions_Fatal( the_source, is_internal, the_error ); 10a149: 53 push %ebx <== NOT EXECUTED 10a14a: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10a14d: 50 push %eax <== NOT EXECUTED 10a14e: 52 push %edx <== NOT EXECUTED 10a14f: e8 eb 18 00 00 call 10ba3f <_User_extensions_Fatal> <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 10a154: c7 05 a0 cb 11 00 05 movl $0x5,0x11cba0 <== NOT EXECUTED 10a15b: 00 00 00 <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10a15e: fa cli <== NOT EXECUTED 10a15f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a161: f4 hlt <== NOT EXECUTED 10a162: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a165: eb fe jmp 10a165 <_Internal_error_Occurred+0x3d> <== NOT EXECUTED 0010d2a0 <_Interrupt_Manager_initialization>: * * Output parameters: NONE */ void _Interrupt_Manager_initialization( void ) { 10d2a0: 55 push %ebp <== NOT EXECUTED 10d2a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED } 10d2a3: c9 leave <== NOT EXECUTED 10d2a4: c3 ret <== NOT EXECUTED 00120db8 <_Message_queue_Allocate>: * Output parameters: * the_message_queue - set if successful, NULL otherwise */ Message_queue_Control *_Message_queue_Allocate(void) { 120db8: 55 push %ebp <== NOT EXECUTED 120db9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120dbb: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED return (Message_queue_Control *) 120dbe: 68 cc 9f 15 00 push $0x159fcc <== NOT EXECUTED 120dc3: e8 ec dd fe ff call 10ebb4 <_Objects_Allocate> <== NOT EXECUTED _Objects_Allocate(&_Message_queue_Information); } 120dc8: c9 leave <== NOT EXECUTED 120dc9: c3 ret <== NOT EXECUTED 0010d2a8 <_Message_queue_Manager_initialization>: */ void _Message_queue_Manager_initialization( uint32_t maximum_message_queues ) { 10d2a8: 55 push %ebp <== NOT EXECUTED 10d2a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d2ab: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d2ae: 6a 04 push $0x4 <== NOT EXECUTED 10d2b0: 6a 00 push $0x0 <== NOT EXECUTED 10d2b2: 68 88 00 00 00 push $0x88 <== NOT EXECUTED 10d2b7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d2ba: 6a 04 push $0x4 <== NOT EXECUTED 10d2bc: 6a 02 push $0x2 <== NOT EXECUTED 10d2be: 68 ac cc 11 00 push $0x11ccac <== NOT EXECUTED 10d2c3: e8 90 d3 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 10d2c8: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_MESSAGE_QUEUE, _Message_queue_MP_Process_packet ); #endif } 10d2cb: c9 leave <== NOT EXECUTED 10d2cc: c3 ret <== NOT EXECUTED 00108f04 <_Message_queue_Translate_core_message_queue_return_code>: }; rtems_status_code _Message_queue_Translate_core_message_queue_return_code ( uint32_t status ) { 108f04: 55 push %ebp <== NOT EXECUTED 108f05: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108f07: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 108f0a: 8b 04 85 4c a9 11 00 mov 0x11a94c(,%eax,4),%eax <== NOT EXECUTED if ( status > CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ) return RTEMS_INTERNAL_ERROR; #endif return _Message_queue_Translate_core_return_code_[status]; } 108f11: c9 leave <== NOT EXECUTED 108f12: c3 ret <== NOT EXECUTED 0010da70 <_Objects_API_maximum_class>: #include int _Objects_API_maximum_class( uint32_t api ) { 10da70: 55 push %ebp <== NOT EXECUTED 10da71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10da73: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED switch (api) { 10da76: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10da7b: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 10da7e: 74 1b je 10da9b <_Objects_API_maximum_class+0x2b> <== NOT EXECUTED 10da80: 77 05 ja 10da87 <_Objects_API_maximum_class+0x17> <== NOT EXECUTED 10da82: b0 02 mov $0x2,%al <== NOT EXECUTED 10da84: 4a dec %edx <== NOT EXECUTED 10da85: eb 0f jmp 10da96 <_Objects_API_maximum_class+0x26> <== NOT EXECUTED 10da87: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED 10da8c: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 10da8f: 74 0a je 10da9b <_Objects_API_maximum_class+0x2b> <== NOT EXECUTED case OBJECTS_INTERNAL_API: return OBJECTS_INTERNAL_CLASSES_LAST; case OBJECTS_CLASSIC_API: return OBJECTS_RTEMS_CLASSES_LAST; case OBJECTS_POSIX_API: return OBJECTS_POSIX_CLASSES_LAST; 10da91: b0 08 mov $0x8,%al <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10da93: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10da96: 74 03 je 10da9b <_Objects_API_maximum_class+0x2b> <== NOT EXECUTED case OBJECTS_CLASSIC_API: return OBJECTS_RTEMS_CLASSES_LAST; case OBJECTS_POSIX_API: return OBJECTS_POSIX_CLASSES_LAST; case OBJECTS_ITRON_API: return OBJECTS_ITRON_CLASSES_LAST; 10da98: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10da9b: c9 leave <== NOT EXECUTED 10da9c: c3 ret <== NOT EXECUTED 0010a1bc <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10a1bc: 55 push %ebp <== NOT EXECUTED 10a1bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a1bf: 56 push %esi <== NOT EXECUTED 10a1c0: 53 push %ebx <== NOT EXECUTED 10a1c1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED * 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 ) 10a1c4: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10a1c6: 83 7b 18 00 cmpl $0x0,0x18(%ebx) <== NOT EXECUTED 10a1ca: 74 59 je 10a225 <_Objects_Allocate+0x69> <== NOT EXECUTED /* * 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 ); 10a1cc: 8d 73 20 lea 0x20(%ebx),%esi <== NOT EXECUTED 10a1cf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a1d2: 56 push %esi <== NOT EXECUTED 10a1d3: e8 6c f8 ff ff call 109a44 <_Chain_Get> <== NOT EXECUTED 10a1d8: 89 c1 mov %eax,%ecx <== NOT EXECUTED if ( information->auto_extend ) { 10a1da: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a1dd: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10a1e1: 74 42 je 10a225 <_Objects_Allocate+0x69> <== NOT EXECUTED /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10a1e3: 85 c0 test %eax,%eax <== NOT EXECUTED 10a1e5: 75 1a jne 10a201 <_Objects_Allocate+0x45> <== NOT EXECUTED _Objects_Extend_information( information ); 10a1e7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a1ea: 53 push %ebx <== NOT EXECUTED 10a1eb: e8 64 00 00 00 call 10a254 <_Objects_Extend_information> <== NOT EXECUTED the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10a1f0: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10a1f3: e8 4c f8 ff ff call 109a44 <_Chain_Get> <== NOT EXECUTED 10a1f8: 89 c1 mov %eax,%ecx <== NOT EXECUTED } if ( the_object ) { 10a1fa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a1fd: 85 c0 test %eax,%eax <== NOT EXECUTED 10a1ff: 74 24 je 10a225 <_Objects_Allocate+0x69> <== NOT EXECUTED uint32_t block; block = _Objects_Get_index( the_object->id ) - 10a201: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10a204: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10a209: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10a20c: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10a212: 29 d0 sub %edx,%eax <== NOT EXECUTED _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]--; 10a214: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a216: f7 73 14 divl 0x14(%ebx) <== NOT EXECUTED 10a219: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10a21c: 03 43 30 add 0x30(%ebx),%eax <== NOT EXECUTED 10a21f: ff 08 decl (%eax) <== NOT EXECUTED information->inactive--; 10a221: 66 ff 4b 2c decw 0x2c(%ebx) <== NOT EXECUTED } } return the_object; } 10a225: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10a227: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a22a: 5b pop %ebx <== NOT EXECUTED 10a22b: 5e pop %esi <== NOT EXECUTED 10a22c: c9 leave <== NOT EXECUTED 10a22d: c3 ret <== NOT EXECUTED 0010a230 <_Objects_Close>: void _Objects_Close( Objects_Information *information, Objects_Control *the_object ) { 10a230: 55 push %ebp <== NOT EXECUTED 10a231: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a233: 53 push %ebx <== NOT EXECUTED 10a234: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a237: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10a23a: 0f b7 51 08 movzwl 0x8(%ecx),%edx <== NOT EXECUTED 10a23e: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10a241: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) <== NOT EXECUTED _Objects_Invalidate_Id( information, the_object ); _Objects_Namespace_remove( information, the_object ); 10a248: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED } 10a24b: 5b pop %ebx <== NOT EXECUTED 10a24c: c9 leave <== NOT EXECUTED Objects_Control *the_object ) { _Objects_Invalidate_Id( information, the_object ); _Objects_Namespace_remove( information, the_object ); 10a24d: e9 c2 04 00 00 jmp 10a714 <_Objects_Namespace_remove> <== NOT EXECUTED 0010a254 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 10a254: 55 push %ebp <== NOT EXECUTED 10a255: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a257: 57 push %edi <== NOT EXECUTED 10a258: 56 push %esi <== NOT EXECUTED 10a259: 53 push %ebx <== NOT EXECUTED 10a25a: 83 ec 5c sub $0x5c,%esp <== NOT EXECUTED 10a25d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 10a260: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10a263: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10a268: 89 45 c8 mov %eax,-0x38(%ebp) <== NOT EXECUTED minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; if ( information->maximum < minimum_index ) 10a26b: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx <== NOT EXECUTED 10a26f: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10a271: 73 13 jae 10a286 <_Objects_Extend_information+0x32> <== NOT EXECUTED 10a273: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED 10a276: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp) <== NOT EXECUTED 10a27d: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp) <== NOT EXECUTED 10a284: eb 35 jmp 10a2bb <_Objects_Extend_information+0x67> <== NOT EXECUTED block_count = 0; else { block_count = information->maximum / information->allocation_size; 10a286: 8b 7b 14 mov 0x14(%ebx),%edi <== NOT EXECUTED 10a289: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10a28b: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a28d: f7 f7 div %edi <== NOT EXECUTED 10a28f: 89 c6 mov %eax,%esi <== NOT EXECUTED 10a291: 89 45 bc mov %eax,-0x44(%ebp) <== NOT EXECUTED 10a294: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 10a297: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED 10a29a: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp) <== NOT EXECUTED 10a2a1: eb 13 jmp 10a2b6 <_Objects_Extend_information+0x62> <== NOT EXECUTED for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) 10a2a3: 8b 43 34 mov 0x34(%ebx),%eax <== NOT EXECUTED 10a2a6: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED 10a2a9: 83 3c 90 00 cmpl $0x0,(%eax,%edx,4) <== NOT EXECUTED 10a2ad: 74 0c je 10a2bb <_Objects_Extend_information+0x67> <== NOT EXECUTED break; else index_base += information->allocation_size; 10a2af: 01 7d c4 add %edi,-0x3c(%ebp) <== NOT EXECUTED if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10a2b2: 42 inc %edx <== NOT EXECUTED 10a2b3: 89 55 c0 mov %edx,-0x40(%ebp) <== NOT EXECUTED 10a2b6: 39 75 c0 cmp %esi,-0x40(%ebp) <== NOT EXECUTED 10a2b9: 72 e8 jb 10a2a3 <_Objects_Extend_information+0x4f> <== NOT EXECUTED /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 10a2bb: 39 4d c4 cmp %ecx,-0x3c(%ebp) <== NOT EXECUTED 10a2be: 0f 82 30 01 00 00 jb 10a3f4 <_Objects_Extend_information+0x1a0> <== NOT EXECUTED /* * Up the block count and maximum */ block_count++; 10a2c4: 8b 75 bc mov -0x44(%ebp),%esi <== NOT EXECUTED 10a2c7: 46 inc %esi <== NOT EXECUTED maximum = information->maximum + information->allocation_size; 10a2c8: 03 4b 14 add 0x14(%ebx),%ecx <== NOT EXECUTED 10a2cb: 89 4d d0 mov %ecx,-0x30(%ebp) <== NOT EXECUTED /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 10a2ce: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10a2d2: 8b 7d c8 mov -0x38(%ebp),%edi <== NOT EXECUTED 10a2d5: 8d 14 39 lea (%ecx,%edi,1),%edx <== NOT EXECUTED 10a2d8: 74 21 je 10a2fb <_Objects_Extend_information+0xa7> <== NOT EXECUTED object_blocks = (void**) 10a2da: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a2dd: 8d 04 76 lea (%esi,%esi,2),%eax <== NOT EXECUTED 10a2e0: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED 10a2e3: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10a2e6: 50 push %eax <== NOT EXECUTED 10a2e7: e8 71 1a 00 00 call 10bd5d <_Workspace_Allocate> <== NOT EXECUTED 10a2ec: 89 45 a0 mov %eax,-0x60(%ebp) <== NOT EXECUTED block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)) ); if ( !object_blocks ) 10a2ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a2f2: 85 c0 test %eax,%eax <== NOT EXECUTED 10a2f4: 75 1d jne 10a313 <_Objects_Extend_information+0xbf> <== NOT EXECUTED 10a2f6: e9 c9 01 00 00 jmp 10a4c4 <_Objects_Extend_information+0x270> <== NOT EXECUTED return; } else { object_blocks = (void**) 10a2fb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a2fe: 8d 04 76 lea (%esi,%esi,2),%eax <== NOT EXECUTED 10a301: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED 10a304: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10a307: 50 push %eax <== NOT EXECUTED 10a308: e8 65 1a 00 00 call 10bd72 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10a30d: 89 45 a0 mov %eax,-0x60(%ebp) <== NOT EXECUTED 10a310: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 10a313: 8b 45 a0 mov -0x60(%ebp),%eax <== NOT EXECUTED 10a316: 8d 04 b0 lea (%eax,%esi,4),%eax <== NOT EXECUTED 10a319: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 10a31c: 8b 55 a0 mov -0x60(%ebp),%edx <== NOT EXECUTED 10a31f: 8d 34 f2 lea (%edx,%esi,8),%esi <== NOT EXECUTED 10a322: 89 75 d4 mov %esi,-0x2c(%ebp) <== NOT EXECUTED * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 10a325: 0f b7 43 10 movzwl 0x10(%ebx),%eax <== NOT EXECUTED 10a329: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a32b: 3b 45 c8 cmp -0x38(%ebp),%eax <== NOT EXECUTED 10a32e: 76 39 jbe 10a369 <_Objects_Extend_information+0x115> <== NOT EXECUTED /* * 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, 10a330: 8b 45 bc mov -0x44(%ebp),%eax <== NOT EXECUTED 10a333: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10a336: 8b 73 34 mov 0x34(%ebx),%esi <== NOT EXECUTED 10a339: 8b 7d a0 mov -0x60(%ebp),%edi <== NOT EXECUTED 10a33c: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10a33e: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 10a340: 8b 73 30 mov 0x30(%ebx),%esi <== NOT EXECUTED 10a343: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED 10a346: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10a348: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 10a34a: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx <== NOT EXECUTED 10a34e: 03 4d c8 add -0x38(%ebp),%ecx <== NOT EXECUTED 10a351: c1 e1 02 shl $0x2,%ecx <== NOT EXECUTED 10a354: 8b 73 1c mov 0x1c(%ebx),%esi <== NOT EXECUTED 10a357: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED 10a35a: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10a35c: eb 10 jmp 10a36e <_Objects_Extend_information+0x11a> <== NOT EXECUTED /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { local_table[ index ] = NULL; 10a35e: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10a361: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) <== NOT EXECUTED else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10a368: 42 inc %edx <== NOT EXECUTED 10a369: 3b 55 c8 cmp -0x38(%ebp),%edx <== NOT EXECUTED 10a36c: 72 f0 jb 10a35e <_Objects_Extend_information+0x10a> <== NOT EXECUTED /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 10a36e: 8b 55 bc mov -0x44(%ebp),%edx <== NOT EXECUTED 10a371: 8b 4d a0 mov -0x60(%ebp),%ecx <== NOT EXECUTED 10a374: c7 04 91 00 00 00 00 movl $0x0,(%ecx,%edx,4) <== NOT EXECUTED inactive_per_block[block_count] = 0; 10a37b: 8b 75 cc mov -0x34(%ebp),%esi <== NOT EXECUTED 10a37e: c7 04 96 00 00 00 00 movl $0x0,(%esi,%edx,4) <== NOT EXECUTED for ( index=index_base ; index < ( information->allocation_size + index_base ); 10a385: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED 10a388: 03 4b 14 add 0x14(%ebx),%ecx <== NOT EXECUTED 10a38b: 8b 7d c4 mov -0x3c(%ebp),%edi <== NOT EXECUTED 10a38e: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10a391: 8d 14 b8 lea (%eax,%edi,4),%edx <== NOT EXECUTED 10a394: 89 f8 mov %edi,%eax <== NOT EXECUTED 10a396: eb 0a jmp 10a3a2 <_Objects_Extend_information+0x14e> <== NOT EXECUTED index++ ) { local_table[ index ] = NULL; 10a398: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { 10a39e: 40 inc %eax <== NOT EXECUTED 10a39f: 83 c2 04 add $0x4,%edx <== NOT EXECUTED object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); 10a3a2: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10a3a4: 72 f2 jb 10a398 <_Objects_Extend_information+0x144> <== NOT EXECUTED index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 10a3a6: 9c pushf <== NOT EXECUTED 10a3a7: fa cli <== NOT EXECUTED 10a3a8: 59 pop %ecx <== NOT EXECUTED old_tables = information->object_blocks; 10a3a9: 8b 73 34 mov 0x34(%ebx),%esi <== NOT EXECUTED information->object_blocks = object_blocks; 10a3ac: 8b 55 a0 mov -0x60(%ebp),%edx <== NOT EXECUTED 10a3af: 89 53 34 mov %edx,0x34(%ebx) <== NOT EXECUTED information->inactive_per_block = inactive_per_block; 10a3b2: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED 10a3b5: 89 7b 30 mov %edi,0x30(%ebx) <== NOT EXECUTED information->local_table = local_table; 10a3b8: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10a3bb: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED information->maximum = maximum; 10a3be: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 10a3c1: 66 89 53 10 mov %dx,0x10(%ebx) <== NOT EXECUTED information->maximum_id = _Objects_Build_id( 10a3c5: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10a3c7: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10a3ca: 81 ca 00 00 01 00 or $0x10000,%edx <== NOT EXECUTED 10a3d0: 0f b7 43 04 movzwl 0x4(%ebx),%eax <== NOT EXECUTED 10a3d4: c1 e0 1b shl $0x1b,%eax <== NOT EXECUTED 10a3d7: 09 c2 or %eax,%edx <== NOT EXECUTED 10a3d9: 0f b7 45 d0 movzwl -0x30(%ebp),%eax <== NOT EXECUTED 10a3dd: 09 c2 or %eax,%edx <== NOT EXECUTED 10a3df: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 10a3e2: 51 push %ecx <== NOT EXECUTED 10a3e3: 9d popf <== NOT EXECUTED if ( old_tables ) 10a3e4: 85 f6 test %esi,%esi <== NOT EXECUTED 10a3e6: 74 0c je 10a3f4 <_Objects_Extend_information+0x1a0> <== NOT EXECUTED _Workspace_Free( old_tables ); 10a3e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a3eb: 56 push %esi <== NOT EXECUTED 10a3ec: e8 57 19 00 00 call 10bd48 <_Workspace_Free> <== NOT EXECUTED 10a3f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 10a3f4: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10a3f8: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10a3fb: 74 32 je 10a42f <_Objects_Extend_information+0x1db> <== NOT EXECUTED information->object_blocks[ block ] = 10a3fd: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED 10a400: 8b 73 34 mov 0x34(%ebx),%esi <== NOT EXECUTED 10a403: 8d 0c 8e lea (%esi,%ecx,4),%ecx <== NOT EXECUTED 10a406: 89 4d d8 mov %ecx,-0x28(%ebp) <== NOT EXECUTED 10a409: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a40c: 0f af 43 14 imul 0x14(%ebx),%eax <== NOT EXECUTED 10a410: 50 push %eax <== NOT EXECUTED 10a411: e8 47 19 00 00 call 10bd5d <_Workspace_Allocate> <== NOT EXECUTED 10a416: 8b 7d d8 mov -0x28(%ebp),%edi <== NOT EXECUTED 10a419: 89 07 mov %eax,(%edi) <== NOT EXECUTED _Workspace_Allocate( (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 10a41b: 8b 43 34 mov 0x34(%ebx),%eax <== NOT EXECUTED 10a41e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a421: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED 10a424: 83 3c 90 00 cmpl $0x0,(%eax,%edx,4) <== NOT EXECUTED 10a428: 75 26 jne 10a450 <_Objects_Extend_information+0x1fc> <== NOT EXECUTED 10a42a: e9 95 00 00 00 jmp 10a4c4 <_Objects_Extend_information+0x270> <== NOT EXECUTED return; } else { information->object_blocks[ block ] = 10a42f: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED 10a432: 8b 73 34 mov 0x34(%ebx),%esi <== NOT EXECUTED 10a435: 8d 0c 8e lea (%esi,%ecx,4),%ecx <== NOT EXECUTED 10a438: 89 4d dc mov %ecx,-0x24(%ebp) <== NOT EXECUTED 10a43b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a43e: 0f af 43 14 imul 0x14(%ebx),%eax <== NOT EXECUTED 10a442: 50 push %eax <== NOT EXECUTED 10a443: e8 2a 19 00 00 call 10bd72 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10a448: 8b 7d dc mov -0x24(%ebp),%edi <== NOT EXECUTED 10a44b: 89 07 mov %eax,(%edi) <== NOT EXECUTED 10a44d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 10a450: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 10a453: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10a456: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10a459: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10a45c: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 10a45f: 8b 43 34 mov 0x34(%ebx),%eax <== NOT EXECUTED 10a462: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED 10a465: ff 34 90 pushl (%eax,%edx,4) <== NOT EXECUTED 10a468: 8d 7d e8 lea -0x18(%ebp),%edi <== NOT EXECUTED 10a46b: 57 push %edi <== NOT EXECUTED 10a46c: e8 f7 31 00 00 call 10d668 <_Chain_Initialize> <== NOT EXECUTED information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10a471: 8d 4b 20 lea 0x20(%ebx),%ecx <== NOT EXECUTED 10a474: 89 4d b8 mov %ecx,-0x48(%ebp) <== NOT EXECUTED 10a477: 8b 75 c4 mov -0x3c(%ebp),%esi <== NOT EXECUTED 10a47a: eb 24 jmp 10a4a0 <_Objects_Extend_information+0x24c> <== NOT EXECUTED index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 10a47c: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10a47e: c1 e0 18 shl $0x18,%eax <== NOT EXECUTED 10a481: 0d 00 00 01 00 or $0x10000,%eax <== NOT EXECUTED 10a486: 0f b7 53 04 movzwl 0x4(%ebx),%edx <== NOT EXECUTED 10a48a: c1 e2 1b shl $0x1b,%edx <== NOT EXECUTED 10a48d: 09 d0 or %edx,%eax <== NOT EXECUTED 10a48f: 09 f0 or %esi,%eax <== NOT EXECUTED 10a491: 89 41 08 mov %eax,0x8(%ecx) <== NOT EXECUTED information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10a494: 50 push %eax <== NOT EXECUTED 10a495: 50 push %eax <== NOT EXECUTED 10a496: 51 push %ecx <== NOT EXECUTED 10a497: ff 75 b8 pushl -0x48(%ebp) <== NOT EXECUTED 10a49a: e8 81 f5 ff ff call 109a20 <_Chain_Append> <== NOT EXECUTED index++; 10a49f: 46 inc %esi <== NOT EXECUTED * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { 10a4a0: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10a4a3: e8 9c f5 ff ff call 109a44 <_Chain_Get> <== NOT EXECUTED 10a4a8: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10a4aa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a4ad: 85 c0 test %eax,%eax <== NOT EXECUTED 10a4af: 75 cb jne 10a47c <_Objects_Extend_information+0x228> <== NOT EXECUTED _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 10a4b1: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10a4b4: 8b 53 14 mov 0x14(%ebx),%edx <== NOT EXECUTED 10a4b7: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED 10a4ba: 89 14 30 mov %edx,(%eax,%esi,1) <== NOT EXECUTED information->inactive += information->allocation_size; 10a4bd: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10a4c0: 66 01 43 2c add %ax,0x2c(%ebx) <== NOT EXECUTED } 10a4c4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a4c7: 5b pop %ebx <== NOT EXECUTED 10a4c8: 5e pop %esi <== NOT EXECUTED 10a4c9: 5f pop %edi <== NOT EXECUTED 10a4ca: c9 leave <== NOT EXECUTED 10a4cb: c3 ret <== NOT EXECUTED 0010a4cc <_Objects_Free>: void _Objects_Free( Objects_Information *information, Objects_Control *the_object ) { 10a4cc: 55 push %ebp <== NOT EXECUTED 10a4cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4cf: 57 push %edi <== NOT EXECUTED 10a4d0: 56 push %esi <== NOT EXECUTED 10a4d1: 53 push %ebx <== NOT EXECUTED 10a4d2: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10a4d5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a4d8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED uint32_t allocation_size = information->allocation_size; 10a4db: 8b 7b 14 mov 0x14(%ebx),%edi <== NOT EXECUTED _Chain_Append( &information->Inactive, &the_object->Node ); 10a4de: 56 push %esi <== NOT EXECUTED 10a4df: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED 10a4e2: 50 push %eax <== NOT EXECUTED 10a4e3: e8 38 f5 ff ff call 109a20 <_Chain_Append> <== NOT EXECUTED if ( information->auto_extend ) { 10a4e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a4eb: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10a4ef: 74 44 je 10a535 <_Objects_Free+0x69> <== NOT EXECUTED uint32_t block; block = 10a4f1: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10a4f4: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10a4f9: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10a4fc: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10a502: 29 d0 sub %edx,%eax <== NOT EXECUTED _Objects_Get_index( the_object->id ) - _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]++; 10a504: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a506: f7 73 14 divl 0x14(%ebx) <== NOT EXECUTED 10a509: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10a50c: 03 43 30 add 0x30(%ebx),%eax <== NOT EXECUTED 10a50f: ff 00 incl (%eax) <== NOT EXECUTED information->inactive++; 10a511: 8b 53 2c mov 0x2c(%ebx),%edx <== NOT EXECUTED 10a514: 42 inc %edx <== NOT EXECUTED 10a515: 66 89 53 2c mov %dx,0x2c(%ebx) <== NOT EXECUTED /* * Check if the threshold level has been met of * 1.5 x allocation_size are free. */ if ( information->inactive > ( allocation_size + ( allocation_size >> 1 ) ) ) { 10a519: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10a51c: 89 f8 mov %edi,%eax <== NOT EXECUTED 10a51e: d1 e8 shr %eax <== NOT EXECUTED 10a520: 01 f8 add %edi,%eax <== NOT EXECUTED 10a522: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10a524: 76 0f jbe 10a535 <_Objects_Free+0x69> <== NOT EXECUTED _Objects_Shrink_information( information ); 10a526: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } } 10a529: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a52c: 5b pop %ebx <== NOT EXECUTED 10a52d: 5e pop %esi <== NOT EXECUTED 10a52e: 5f pop %edi <== NOT EXECUTED 10a52f: c9 leave <== NOT EXECUTED * Check if the threshold level has been met of * 1.5 x allocation_size are free. */ if ( information->inactive > ( allocation_size + ( allocation_size >> 1 ) ) ) { _Objects_Shrink_information( information ); 10a530: e9 87 02 00 00 jmp 10a7bc <_Objects_Shrink_information> <== NOT EXECUTED } } } 10a535: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a538: 5b pop %ebx <== NOT EXECUTED 10a539: 5e pop %esi <== NOT EXECUTED 10a53a: 5f pop %edi <== NOT EXECUTED 10a53b: c9 leave <== NOT EXECUTED 10a53c: c3 ret <== NOT EXECUTED 0010a600 <_Objects_Get>: Objects_Control *_Objects_Get( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 10a600: 55 push %ebp <== NOT EXECUTED 10a601: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a603: 56 push %esi <== NOT EXECUTED 10a604: 53 push %ebx <== NOT EXECUTED 10a605: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10a608: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED * always NULL. * * If the Id is valid but the object has not been created yet, then * the local_table entry will be NULL. */ index = id - information->minimum_id + 1; 10a60b: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10a610: 2b 51 08 sub 0x8(%ecx),%edx <== NOT EXECUTED 10a613: 03 55 0c add 0xc(%ebp),%edx <== NOT EXECUTED /* * If the index is less than maximum, then it is OK to use it to * index into the local_table array. */ if ( index <= information->maximum ) { 10a616: 0f b7 41 10 movzwl 0x10(%ecx),%eax <== NOT EXECUTED 10a61a: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10a61c: 77 2a ja 10a648 <_Objects_Get+0x48> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a61e: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10a623: 40 inc %eax <== NOT EXECUTED 10a624: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED _Thread_Disable_dispatch(); if ( (the_object = information->local_table[ index ]) != NULL ) { 10a629: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 10a62c: 8b 1c 90 mov (%eax,%edx,4),%ebx <== NOT EXECUTED 10a62f: 85 db test %ebx,%ebx <== NOT EXECUTED 10a631: 74 08 je 10a63b <_Objects_Get+0x3b> <== NOT EXECUTED *location = OBJECTS_LOCAL; 10a633: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED 10a639: eb 15 jmp 10a650 <_Objects_Get+0x50> <== NOT EXECUTED /* * Valid Id for this API, Class and Node but the object has not * been allocated yet. */ _Thread_Enable_dispatch(); 10a63b: e8 80 07 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED *location = OBJECTS_ERROR; 10a640: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 10a646: eb 08 jmp 10a650 <_Objects_Get+0x50> <== NOT EXECUTED /* * Object Id is not within this API and Class on this node. So * it may be global in a multiprocessing system. But it is clearly * invalid on a single processor system. */ *location = OBJECTS_ERROR; 10a648: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 10a64e: 31 db xor %ebx,%ebx <== NOT EXECUTED _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 10a650: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a652: 5b pop %ebx <== NOT EXECUTED 10a653: 5e pop %esi <== NOT EXECUTED 10a654: c9 leave <== NOT EXECUTED 10a655: c3 ret <== NOT EXECUTED 0010a560 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint32_t the_class ) { 10a560: 55 push %ebp <== NOT EXECUTED 10a561: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a563: 56 push %esi <== NOT EXECUTED 10a564: 53 push %ebx <== NOT EXECUTED 10a565: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a568: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10a56b: 8d 43 ff lea -0x1(%ebx),%eax <== NOT EXECUTED 10a56e: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10a571: 77 2f ja 10a5a2 <_Objects_Get_information+0x42> <== NOT EXECUTED 10a573: eb 36 jmp 10a5ab <_Objects_Get_information+0x4b> <== NOT EXECUTED return NULL; if ( !the_class ) return NULL; the_class_api_maximum = _Objects_API_maximum_class( the_api ); 10a575: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a578: 53 push %ebx <== NOT EXECUTED 10a579: e8 f2 34 00 00 call 10da70 <_Objects_API_maximum_class> <== NOT EXECUTED if ( the_class_api_maximum < 0 || 10a57e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a581: 85 c0 test %eax,%eax <== NOT EXECUTED 10a583: 78 1d js 10a5a2 <_Objects_Get_information+0x42> <== NOT EXECUTED 10a585: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10a587: 77 19 ja 10a5a2 <_Objects_Get_information+0x42> <== NOT EXECUTED the_class > (uint32_t) the_class_api_maximum ) return NULL; if ( !_Objects_Information_table[ the_api ] ) 10a589: 8b 04 9d d4 c9 11 00 mov 0x11c9d4(,%ebx,4),%eax <== NOT EXECUTED 10a590: 85 c0 test %eax,%eax <== NOT EXECUTED 10a592: 74 0e je 10a5a2 <_Objects_Get_information+0x42> <== NOT EXECUTED return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10a594: 8b 04 b0 mov (%eax,%esi,4),%eax <== NOT EXECUTED if ( !info ) 10a597: 85 c0 test %eax,%eax <== NOT EXECUTED 10a599: 74 09 je 10a5a4 <_Objects_Get_information+0x44> <== NOT EXECUTED * 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 ) 10a59b: 66 83 78 10 00 cmpw $0x0,0x10(%eax) <== NOT EXECUTED 10a5a0: 75 02 jne 10a5a4 <_Objects_Get_information+0x44> <== NOT EXECUTED 10a5a2: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; #endif return info; } 10a5a4: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a5a7: 5b pop %ebx <== NOT EXECUTED 10a5a8: 5e pop %esi <== NOT EXECUTED 10a5a9: c9 leave <== NOT EXECUTED 10a5aa: c3 ret <== NOT EXECUTED int the_class_api_maximum; if ( !_Objects_Is_api_valid( the_api ) ) return NULL; if ( !the_class ) 10a5ab: 85 f6 test %esi,%esi <== NOT EXECUTED 10a5ad: 74 f3 je 10a5a2 <_Objects_Get_information+0x42> <== NOT EXECUTED 10a5af: eb c4 jmp 10a575 <_Objects_Get_information+0x15> <== NOT EXECUTED 0010a540 <_Objects_Get_information_id>: #include Objects_Information *_Objects_Get_information_id( Objects_Id id ) { 10a540: 55 push %ebp <== NOT EXECUTED 10a541: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a543: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10a546: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED return _Objects_Get_information( 10a549: 89 c2 mov %eax,%edx <== NOT EXECUTED 10a54b: c1 ea 1b shr $0x1b,%edx <== NOT EXECUTED 10a54e: 52 push %edx <== NOT EXECUTED 10a54f: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10a552: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 10a555: 50 push %eax <== NOT EXECUTED 10a556: e8 05 00 00 00 call 10a560 <_Objects_Get_information> <== NOT EXECUTED _Objects_Get_API( id ), _Objects_Get_class( id ) ); } 10a55b: c9 leave <== NOT EXECUTED 10a55c: c3 ret <== NOT EXECUTED 0010a5b4 <_Objects_Get_isr_disable>: Objects_Information *information, Objects_Id id, Objects_Locations *location, ISR_Level *level_p ) { 10a5b4: 55 push %ebp <== NOT EXECUTED 10a5b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a5b7: 56 push %esi <== NOT EXECUTED 10a5b8: 53 push %ebx <== NOT EXECUTED 10a5b9: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10a5bc: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) index = id - information->minimum_id + 1; #else /* index = _Objects_Get_index( id ); */ index = id & 0x0000ffff; 10a5bf: 0f b7 55 0c movzwl 0xc(%ebp),%edx <== NOT EXECUTED /* This should work but doesn't always :( */ /* index = (uint16_t ) id; */ #endif _ISR_Disable( level ); 10a5c3: 9c pushf <== NOT EXECUTED 10a5c4: fa cli <== NOT EXECUTED 10a5c5: 59 pop %ecx <== NOT EXECUTED if ( information->maximum >= index ) { 10a5c6: 0f b7 46 10 movzwl 0x10(%esi),%eax <== NOT EXECUTED 10a5ca: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10a5cc: 72 21 jb 10a5ef <_Objects_Get_isr_disable+0x3b> <== NOT EXECUTED if ( (the_object = information->local_table[ index ]) != NULL ) { 10a5ce: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED 10a5d1: 8b 14 90 mov (%eax,%edx,4),%edx <== NOT EXECUTED 10a5d4: 85 d2 test %edx,%edx <== NOT EXECUTED 10a5d6: 74 0d je 10a5e5 <_Objects_Get_isr_disable+0x31> <== NOT EXECUTED *location = OBJECTS_LOCAL; 10a5d8: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED *level_p = level; 10a5de: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a5e1: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10a5e3: eb 14 jmp 10a5f9 <_Objects_Get_isr_disable+0x45> <== NOT EXECUTED return the_object; } _ISR_Enable( level ); 10a5e5: 51 push %ecx <== NOT EXECUTED 10a5e6: 9d popf <== NOT EXECUTED *location = OBJECTS_ERROR; 10a5e7: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED 10a5ed: eb 0a jmp 10a5f9 <_Objects_Get_isr_disable+0x45> <== NOT EXECUTED return NULL; } _ISR_Enable( level ); 10a5ef: 51 push %ecx <== NOT EXECUTED 10a5f0: 9d popf <== NOT EXECUTED *location = OBJECTS_ERROR; 10a5f1: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED 10a5f7: 31 d2 xor %edx,%edx <== NOT EXECUTED _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 10a5f9: 89 d0 mov %edx,%eax <== NOT EXECUTED 10a5fb: 5b pop %ebx <== NOT EXECUTED 10a5fc: 5e pop %esi <== NOT EXECUTED 10a5fd: c9 leave <== NOT EXECUTED 10a5fe: c3 ret <== NOT EXECUTED 00112f18 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 112f18: 55 push %ebp <== NOT EXECUTED 112f19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112f1b: 57 push %edi <== NOT EXECUTED 112f1c: 56 push %esi <== NOT EXECUTED 112f1d: 53 push %ebx <== NOT EXECUTED 112f1e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED char lname[5]; Objects_Control *the_object; Objects_Locations location; Objects_Id tmpId; if ( length == 0 ) 112f21: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 112f25: 0f 84 b3 00 00 00 je 112fde <_Objects_Get_name_as_string+0xc6> <== NOT EXECUTED return NULL; if ( name == NULL ) 112f2b: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 112f2f: 0f 84 b0 00 00 00 je 112fe5 <_Objects_Get_name_as_string+0xcd> <== NOT EXECUTED return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 112f35: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 112f38: 85 db test %ebx,%ebx <== NOT EXECUTED 112f3a: 75 08 jne 112f44 <_Objects_Get_name_as_string+0x2c> <== NOT EXECUTED 112f3c: a1 44 89 12 00 mov 0x128944,%eax <== NOT EXECUTED 112f41: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 112f44: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112f47: 53 push %ebx <== NOT EXECUTED 112f48: e8 6f ac ff ff call 10dbbc <_Objects_Get_information_id> <== NOT EXECUTED 112f4d: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( !information ) 112f4f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112f52: 85 c0 test %eax,%eax <== NOT EXECUTED 112f54: 0f 84 84 00 00 00 je 112fde <_Objects_Get_name_as_string+0xc6> <== NOT EXECUTED return NULL; the_object = _Objects_Get( information, tmpId, &location ); 112f5a: 50 push %eax <== NOT EXECUTED 112f5b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 112f5e: 50 push %eax <== NOT EXECUTED 112f5f: 53 push %ebx <== NOT EXECUTED 112f60: 56 push %esi <== NOT EXECUTED 112f61: e8 16 ad ff ff call 10dc7c <_Objects_Get> <== NOT EXECUTED switch ( location ) { 112f66: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112f69: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 112f6d: 75 6f jne 112fde <_Objects_Get_name_as_string+0xc6> <== NOT EXECUTED case OBJECTS_ERROR: return NULL; case OBJECTS_LOCAL: if ( information->is_string ) { 112f6f: 80 7e 38 00 cmpb $0x0,0x38(%esi) <== NOT EXECUTED 112f73: 74 0c je 112f81 <_Objects_Get_name_as_string+0x69> <== NOT EXECUTED s = the_object->name.name_p; 112f75: 8b 78 0c mov 0xc(%eax),%edi <== NOT EXECUTED lname[ 4 ] = '\0'; s = lname; } d = name; if ( s ) { 112f78: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 112f7b: 85 ff test %edi,%edi <== NOT EXECUTED 112f7d: 75 27 jne 112fa6 <_Objects_Get_name_as_string+0x8e> <== NOT EXECUTED 112f7f: eb 53 jmp 112fd4 <_Objects_Get_name_as_string+0xbc> <== NOT EXECUTED case OBJECTS_LOCAL: if ( information->is_string ) { s = the_object->name.name_p; } else { uint32_t u32_name = (uint32_t) the_object->name.name_u32; 112f81: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED lname[ 0 ] = (u32_name >> 24) & 0xff; 112f84: 89 d0 mov %edx,%eax <== NOT EXECUTED 112f86: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 112f89: 88 45 eb mov %al,-0x15(%ebp) <== NOT EXECUTED lname[ 1 ] = (u32_name >> 16) & 0xff; 112f8c: 89 d0 mov %edx,%eax <== NOT EXECUTED 112f8e: c1 e8 10 shr $0x10,%eax <== NOT EXECUTED 112f91: 88 45 ec mov %al,-0x14(%ebp) <== NOT EXECUTED lname[ 2 ] = (u32_name >> 8) & 0xff; 112f94: 89 d0 mov %edx,%eax <== NOT EXECUTED 112f96: c1 e8 08 shr $0x8,%eax <== NOT EXECUTED 112f99: 88 45 ed mov %al,-0x13(%ebp) <== NOT EXECUTED lname[ 3 ] = (u32_name >> 0) & 0xff; 112f9c: 88 55 ee mov %dl,-0x12(%ebp) <== NOT EXECUTED lname[ 4 ] = '\0'; 112f9f: c6 45 ef 00 movb $0x0,-0x11(%ebp) <== NOT EXECUTED 112fa3: 8d 7d eb lea -0x15(%ebp),%edi <== NOT EXECUTED 112fa6: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 112fa9: 31 db xor %ebx,%ebx <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 112fab: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 112fae: 48 dec %eax <== NOT EXECUTED 112faf: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 112fb2: eb 14 jmp 112fc8 <_Objects_Get_name_as_string+0xb0> <== NOT EXECUTED *d = (isprint(*s)) ? *s : '*'; 112fb4: 0f be d1 movsbl %cl,%edx <== NOT EXECUTED 112fb7: a1 34 61 12 00 mov 0x126134,%eax <== NOT EXECUTED 112fbc: f6 04 10 97 testb $0x97,(%eax,%edx,1) <== NOT EXECUTED 112fc0: 75 02 jne 112fc4 <_Objects_Get_name_as_string+0xac> <== NOT EXECUTED 112fc2: b1 2a mov $0x2a,%cl <== NOT EXECUTED 112fc4: 88 0e mov %cl,(%esi) <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 112fc6: 43 inc %ebx <== NOT EXECUTED 112fc7: 46 inc %esi <== NOT EXECUTED 112fc8: 3b 5d e0 cmp -0x20(%ebp),%ebx <== NOT EXECUTED 112fcb: 73 07 jae 112fd4 <_Objects_Get_name_as_string+0xbc> <== NOT EXECUTED 112fcd: 8a 0c 1f mov (%edi,%ebx,1),%cl <== NOT EXECUTED 112fd0: 84 c9 test %cl,%cl <== NOT EXECUTED 112fd2: 75 e0 jne 112fb4 <_Objects_Get_name_as_string+0x9c> <== NOT EXECUTED *d = (isprint(*s)) ? *s : '*'; } } *d = '\0'; 112fd4: c6 06 00 movb $0x0,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 112fd7: e8 60 b4 ff ff call 10e43c <_Thread_Enable_dispatch> <== NOT EXECUTED 112fdc: eb 07 jmp 112fe5 <_Objects_Get_name_as_string+0xcd> <== NOT EXECUTED return name; 112fde: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) <== NOT EXECUTED } return NULL; /* unreachable path */ } 112fe5: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 112fe8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112feb: 5b pop %ebx <== NOT EXECUTED 112fec: 5e pop %esi <== NOT EXECUTED 112fed: 5f pop %edi <== NOT EXECUTED 112fee: c9 leave <== NOT EXECUTED 112fef: c3 ret <== NOT EXECUTED 001150e4 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 1150e4: 55 push %ebp <== NOT EXECUTED 1150e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1150e7: 57 push %edi <== NOT EXECUTED 1150e8: 56 push %esi <== NOT EXECUTED 1150e9: 53 push %ebx <== NOT EXECUTED 1150ea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1150ed: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 1150f0: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Objects_Control *object; Objects_Id next_id; if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX) 1150f3: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 1150f6: 66 85 db test %bx,%bx <== NOT EXECUTED 1150f9: 75 03 jne 1150fe <_Objects_Get_next+0x1a> <== NOT EXECUTED next_id = information->minimum_id; 1150fb: 8b 5f 08 mov 0x8(%edi),%ebx <== NOT EXECUTED else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 1150fe: 66 39 5f 10 cmp %bx,0x10(%edi) <== NOT EXECUTED 115102: 73 13 jae 115117 <_Objects_Get_next+0x33> <== NOT EXECUTED { *location_p = OBJECTS_ERROR; 115104: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 11510a: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 11510d: c7 00 ff ff ff ff movl $0xffffffff,(%eax) <== NOT EXECUTED 115113: 31 c0 xor %eax,%eax <== NOT EXECUTED 115115: eb 17 jmp 11512e <_Objects_Get_next+0x4a> <== NOT EXECUTED *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 115117: 50 push %eax <== NOT EXECUTED 115118: 56 push %esi <== NOT EXECUTED 115119: 53 push %ebx <== NOT EXECUTED 11511a: 57 push %edi <== NOT EXECUTED 11511b: e8 5c 8b ff ff call 10dc7c <_Objects_Get> <== NOT EXECUTED next_id++; 115120: 43 inc %ebx <== NOT EXECUTED } while (*location_p != OBJECTS_LOCAL); 115121: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115124: 83 3e 00 cmpl $0x0,(%esi) <== NOT EXECUTED 115127: 75 d5 jne 1150fe <_Objects_Get_next+0x1a> <== NOT EXECUTED *next_id_p = next_id; 115129: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 11512c: 89 1a mov %ebx,(%edx) <== NOT EXECUTED return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 11512e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 115131: 5b pop %ebx <== NOT EXECUTED 115132: 5e pop %esi <== NOT EXECUTED 115133: 5f pop %edi <== NOT EXECUTED 115134: c9 leave <== NOT EXECUTED 115135: c3 ret <== NOT EXECUTED 00114ef0 <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 114ef0: 55 push %ebp <== NOT EXECUTED 114ef1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114ef3: 53 push %ebx <== NOT EXECUTED 114ef4: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 114ef7: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED /* * 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; 114efa: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 114eff: 2b 51 08 sub 0x8(%ecx),%edx <== NOT EXECUTED 114f02: 03 55 0c add 0xc(%ebp),%edx <== NOT EXECUTED if ( information->maximum >= index ) { 114f05: 0f b7 41 10 movzwl 0x10(%ecx),%eax <== NOT EXECUTED 114f09: 39 d0 cmp %edx,%eax <== NOT EXECUTED 114f0b: 72 12 jb 114f1f <_Objects_Get_no_protection+0x2f> <== NOT EXECUTED if ( (the_object = information->local_table[ index ]) != NULL ) { 114f0d: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 114f10: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED 114f13: 85 c0 test %eax,%eax <== NOT EXECUTED 114f15: 74 08 je 114f1f <_Objects_Get_no_protection+0x2f> <== NOT EXECUTED *location = OBJECTS_LOCAL; 114f17: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED 114f1d: eb 08 jmp 114f27 <_Objects_Get_no_protection+0x37> <== NOT EXECUTED /* * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ *location = OBJECTS_ERROR; 114f1f: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED 114f25: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; } 114f27: 5b pop %ebx <== NOT EXECUTED 114f28: c9 leave <== NOT EXECUTED 114f29: c3 ret <== NOT EXECUTED 0010a7b4 <_Objects_Handler_initialization>: uint32_t maximum_nodes, uint32_t maximum_global_objects ) #else void _Objects_Handler_initialization(void) #endif { 10a7b4: 55 push %ebp <== NOT EXECUTED 10a7b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED node, maximum_nodes, maximum_global_objects ); #endif } 10a7b7: c9 leave <== NOT EXECUTED 10a7b8: c3 ret <== NOT EXECUTED 0010b5a0 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10b5a0: 55 push %ebp <== NOT EXECUTED 10b5a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b5a3: 53 push %ebx <== NOT EXECUTED 10b5a4: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10b5a7: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Objects_Id tmpId; Objects_Information *information; Objects_Control *the_object = (Objects_Control *) 0; Objects_Locations ignored_location; if ( !name ) 10b5aa: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10b5af: 85 db test %ebx,%ebx <== NOT EXECUTED 10b5b1: 74 59 je 10b60c <_Objects_Id_to_name+0x6c> <== NOT EXECUTED return OBJECTS_INVALID_NAME; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10b5b3: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b5b6: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b5b8: 75 08 jne 10b5c2 <_Objects_Id_to_name+0x22> <== NOT EXECUTED 10b5ba: a1 8c f5 11 00 mov 0x11f58c,%eax <== NOT EXECUTED 10b5bf: 8b 48 08 mov 0x8(%eax),%ecx <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10b5c2: 89 ca mov %ecx,%edx <== NOT EXECUTED 10b5c4: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10b5c7: 83 e2 07 and $0x7,%edx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10b5ca: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10b5cd: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b5d0: 77 35 ja 10b607 <_Objects_Id_to_name+0x67> <== NOT EXECUTED 10b5d2: eb 3d jmp 10b611 <_Objects_Id_to_name+0x71> <== NOT EXECUTED if ( !_Objects_Information_table[ the_api ] ) return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 10b5d4: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b5d6: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED 10b5d9: 8b 14 82 mov (%edx,%eax,4),%edx <== NOT EXECUTED if ( !information ) 10b5dc: 85 d2 test %edx,%edx <== NOT EXECUTED 10b5de: 74 27 je 10b607 <_Objects_Id_to_name+0x67> <== NOT EXECUTED return OBJECTS_INVALID_ID; if ( information->is_string ) 10b5e0: 80 7a 38 00 cmpb $0x0,0x38(%edx) <== NOT EXECUTED 10b5e4: 75 21 jne 10b607 <_Objects_Id_to_name+0x67> <== NOT EXECUTED return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &ignored_location ); 10b5e6: 50 push %eax <== NOT EXECUTED 10b5e7: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10b5ea: 50 push %eax <== NOT EXECUTED 10b5eb: 51 push %ecx <== NOT EXECUTED 10b5ec: 52 push %edx <== NOT EXECUTED 10b5ed: e8 56 ff ff ff call 10b548 <_Objects_Get> <== NOT EXECUTED if ( !the_object ) 10b5f2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b5f5: 85 c0 test %eax,%eax <== NOT EXECUTED 10b5f7: 74 0e je 10b607 <_Objects_Id_to_name+0x67> <== NOT EXECUTED return OBJECTS_INVALID_ID; *name = the_object->name; 10b5f9: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10b5fc: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10b5fe: e8 85 07 00 00 call 10bd88 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b603: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b605: eb 05 jmp 10b60c <_Objects_Id_to_name+0x6c> <== NOT EXECUTED return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10b607: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } 10b60c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b60f: c9 leave <== NOT EXECUTED 10b610: c3 ret <== NOT EXECUTED the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) 10b611: 8b 14 95 a0 f4 11 00 mov 0x11f4a0(,%edx,4),%edx <== NOT EXECUTED 10b618: 85 d2 test %edx,%edx <== NOT EXECUTED 10b61a: 75 b8 jne 10b5d4 <_Objects_Id_to_name+0x34> <== NOT EXECUTED 10b61c: eb e9 jmp 10b607 <_Objects_Id_to_name+0x67> <== NOT EXECUTED 0010a658 <_Objects_Initialize_information>: , bool supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 10a658: 55 push %ebp <== NOT EXECUTED 10a659: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a65b: 57 push %edi <== NOT EXECUTED 10a65c: 56 push %esi <== NOT EXECUTED 10a65d: 53 push %ebx <== NOT EXECUTED 10a65e: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10a661: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10a664: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10a667: 8b 75 20 mov 0x20(%ebp),%esi <== NOT EXECUTED 10a66a: 0f b7 4d 18 movzwl 0x18(%ebp),%ecx <== NOT EXECUTED uint32_t name_length; #if defined(RTEMS_MULTIPROCESSING) uint32_t index; #endif information->the_api = the_api; 10a66e: 89 17 mov %edx,(%edi) <== NOT EXECUTED information->the_class = the_class; 10a670: 66 89 5f 04 mov %bx,0x4(%edi) <== NOT EXECUTED information->is_string = is_string; 10a674: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 10a677: 88 47 38 mov %al,0x38(%edi) <== NOT EXECUTED information->local_table = 0; information->inactive_per_block = 0; 10a67a: c7 47 30 00 00 00 00 movl $0x0,0x30(%edi) <== NOT EXECUTED information->object_blocks = 0; 10a681: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi) <== NOT EXECUTED information->inactive = 0; 10a688: 66 c7 47 2c 00 00 movw $0x0,0x2c(%edi) <== NOT EXECUTED /* * Set the entry in the object information table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 10a68e: 8b 04 95 d4 c9 11 00 mov 0x11c9d4(,%edx,4),%eax <== NOT EXECUTED 10a695: 89 3c 98 mov %edi,(%eax,%ebx,4) <== NOT EXECUTED /* * Set the size of the object */ information->size = size; 10a698: 89 4f 18 mov %ecx,0x18(%edi) <== NOT EXECUTED /* * Are we operating in unlimited, or auto-extend mode */ information->auto_extend = 10a69b: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a69e: c1 e8 1f shr $0x1f,%eax <== NOT EXECUTED 10a6a1: 88 47 12 mov %al,0x12(%edi) <== NOT EXECUTED (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE; maximum &= ~OBJECTS_UNLIMITED_OBJECTS; 10a6a4: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10a6a7: 81 e1 ff ff ff 7f and $0x7fffffff,%ecx <== NOT EXECUTED /* * The allocation unit is the maximum value */ information->allocation_size = maximum; 10a6ad: 89 4f 14 mov %ecx,0x14(%edi) <== NOT EXECUTED /* * Provide a null local table entry for the case of any empty table. */ information->local_table = &null_local_table; 10a6b0: c7 47 1c b8 c7 11 00 movl $0x11c7b8,0x1c(%edi) <== NOT EXECUTED */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 10a6b7: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10a6ba: 81 ca 00 00 01 00 or $0x10000,%edx <== NOT EXECUTED 10a6c0: c1 e3 1b shl $0x1b,%ebx <== NOT EXECUTED 10a6c3: 09 da or %ebx,%edx <== NOT EXECUTED 10a6c5: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a6c7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a6c9: 0f 95 c0 setne %al <== NOT EXECUTED 10a6cc: 09 c2 or %eax,%edx <== NOT EXECUTED 10a6ce: 89 57 08 mov %edx,0x8(%edi) <== NOT EXECUTED * Calculate the maximum name length */ name_length = maximum_name_length; if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) ) 10a6d1: 89 f0 mov %esi,%eax <== NOT EXECUTED 10a6d3: f7 c6 03 00 00 00 test $0x3,%esi <== NOT EXECUTED 10a6d9: 74 06 je 10a6e1 <_Objects_Initialize_information+0x89> <== NOT EXECUTED name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & 10a6db: 8d 46 04 lea 0x4(%esi),%eax <== NOT EXECUTED 10a6de: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED ~(OBJECTS_NAME_ALIGNMENT-1); information->name_length = name_length; 10a6e1: 66 89 47 3a mov %ax,0x3a(%edi) <== NOT EXECUTED 10a6e5: 8d 47 24 lea 0x24(%edi),%eax <== NOT EXECUTED 10a6e8: 89 47 20 mov %eax,0x20(%edi) <== NOT EXECUTED 10a6eb: c7 47 24 00 00 00 00 movl $0x0,0x24(%edi) <== NOT EXECUTED 10a6f2: 8d 47 20 lea 0x20(%edi),%eax <== NOT EXECUTED 10a6f5: 89 47 28 mov %eax,0x28(%edi) <== NOT EXECUTED /* * Initialize objects .. if there are any */ if ( maximum ) { 10a6f8: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a6fa: 74 12 je 10a70e <_Objects_Initialize_information+0xb6> <== NOT EXECUTED /* * Reset the maximum value. It will be updated when the information is * extended. */ information->maximum = 0; 10a6fc: 66 c7 47 10 00 00 movw $0x0,0x10(%edi) <== NOT EXECUTED * Always have the maximum size available so the current performance * figures are create are met. If the user moves past the maximum * number then a performance hit is taken. */ _Objects_Extend_information( information ); 10a702: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10a705: 5b pop %ebx <== NOT EXECUTED 10a706: 5e pop %esi <== NOT EXECUTED 10a707: 5f pop %edi <== NOT EXECUTED 10a708: c9 leave <== NOT EXECUTED * Always have the maximum size available so the current performance * figures are create are met. If the user moves past the maximum * number then a performance hit is taken. */ _Objects_Extend_information( information ); 10a709: e9 46 fb ff ff jmp 10a254 <_Objects_Extend_information> <== NOT EXECUTED _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10a70e: 5b pop %ebx <== NOT EXECUTED 10a70f: 5e pop %esi <== NOT EXECUTED 10a710: 5f pop %edi <== NOT EXECUTED 10a711: c9 leave <== NOT EXECUTED 10a712: c3 ret <== NOT EXECUTED 0010a748 <_Objects_Name_to_id_u32>: Objects_Information *information, uint32_t name, uint32_t node, Objects_Id *id ) { 10a748: 55 push %ebp <== NOT EXECUTED 10a749: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a74b: 57 push %edi <== NOT EXECUTED 10a74c: 56 push %esi <== NOT EXECUTED 10a74d: 53 push %ebx <== NOT EXECUTED 10a74e: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10a751: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10a754: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10a757: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == FALSE */ if ( !id ) 10a75a: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10a75f: 85 f6 test %esi,%esi <== NOT EXECUTED 10a761: 74 49 je 10a7ac <_Objects_Name_to_id_u32+0x64> <== NOT EXECUTED return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 10a763: 85 db test %ebx,%ebx <== NOT EXECUTED 10a765: 74 40 je 10a7a7 <_Objects_Name_to_id_u32+0x5f> <== NOT EXECUTED return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10a767: 8b 47 10 mov 0x10(%edi),%eax <== NOT EXECUTED 10a76a: 66 85 c0 test %ax,%ax <== NOT EXECUTED 10a76d: 74 38 je 10a7a7 <_Objects_Name_to_id_u32+0x5f> <== NOT EXECUTED 10a76f: 85 d2 test %edx,%edx <== NOT EXECUTED 10a771: 74 28 je 10a79b <_Objects_Name_to_id_u32+0x53> <== NOT EXECUTED 10a773: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx <== NOT EXECUTED 10a779: 74 20 je 10a79b <_Objects_Name_to_id_u32+0x53> <== NOT EXECUTED 10a77b: 4a dec %edx <== NOT EXECUTED 10a77c: 75 29 jne 10a7a7 <_Objects_Name_to_id_u32+0x5f> <== NOT EXECUTED 10a77e: eb 1b jmp 10a79b <_Objects_Name_to_id_u32+0x53> <== NOT EXECUTED if ( search_local_node ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { the_object = information->local_table[ index ]; 10a780: 8b 47 1c mov 0x1c(%edi),%eax <== NOT EXECUTED 10a783: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED if ( !the_object ) 10a786: 85 c0 test %eax,%eax <== NOT EXECUTED 10a788: 74 0e je 10a798 <_Objects_Name_to_id_u32+0x50> <== NOT EXECUTED continue; if ( name == the_object->name.name_u32 ) { 10a78a: 3b 58 0c cmp 0xc(%eax),%ebx <== NOT EXECUTED 10a78d: 75 09 jne 10a798 <_Objects_Name_to_id_u32+0x50> <== NOT EXECUTED *id = the_object->id; 10a78f: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10a792: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10a794: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a796: eb 14 jmp 10a7ac <_Objects_Name_to_id_u32+0x64> <== NOT EXECUTED search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 10a798: 42 inc %edx <== NOT EXECUTED 10a799: eb 08 jmp 10a7a3 <_Objects_Name_to_id_u32+0x5b> <== NOT EXECUTED 10a79b: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10a7a0: 0f b7 c8 movzwl %ax,%ecx <== NOT EXECUTED 10a7a3: 39 ca cmp %ecx,%edx <== NOT EXECUTED 10a7a5: 76 d9 jbe 10a780 <_Objects_Name_to_id_u32+0x38> <== NOT EXECUTED 10a7a7: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; #endif } 10a7ac: 5b pop %ebx <== NOT EXECUTED 10a7ad: 5e pop %esi <== NOT EXECUTED 10a7ae: 5f pop %edi <== NOT EXECUTED 10a7af: c9 leave <== NOT EXECUTED 10a7b0: c3 ret <== NOT EXECUTED 0010a714 <_Objects_Namespace_remove>: void _Objects_Namespace_remove( Objects_Information *information, Objects_Control *the_object ) { 10a714: 55 push %ebp <== NOT EXECUTED 10a715: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a717: 53 push %ebx <== NOT EXECUTED 10a718: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a71b: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED /* * If this is a string format name, then free the memory. */ if ( information->is_string && the_object->name.name_p ) 10a71e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a721: 80 78 38 00 cmpb $0x0,0x38(%eax) <== NOT EXECUTED 10a725: 74 13 je 10a73a <_Objects_Namespace_remove+0x26> <== NOT EXECUTED 10a727: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10a72a: 85 c0 test %eax,%eax <== NOT EXECUTED 10a72c: 74 0c je 10a73a <_Objects_Namespace_remove+0x26> <== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10a72e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a731: 50 push %eax <== NOT EXECUTED 10a732: e8 11 16 00 00 call 10bd48 <_Workspace_Free> <== NOT EXECUTED 10a737: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Clear out either format. */ the_object->name.name_p = NULL; the_object->name.name_u32 = 0; 10a73a: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED } 10a741: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a744: c9 leave <== NOT EXECUTED 10a745: c3 ret <== NOT EXECUTED 0010bf8c <_Objects_Set_name>: bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 10bf8c: 55 push %ebp <== NOT EXECUTED 10bf8d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bf8f: 57 push %edi <== NOT EXECUTED 10bf90: 56 push %esi <== NOT EXECUTED 10bf91: 53 push %ebx <== NOT EXECUTED 10bf92: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10bf95: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bf98: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED size_t length; const char *s; s = name; length = strnlen( name, information->name_length ) + 1; 10bf9b: 0f b7 43 3a movzwl 0x3a(%ebx),%eax <== NOT EXECUTED 10bf9f: 50 push %eax <== NOT EXECUTED 10bfa0: 57 push %edi <== NOT EXECUTED 10bfa1: e8 de 56 00 00 call 111684 <== NOT EXECUTED 10bfa6: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 10bfa9: 89 c6 mov %eax,%esi <== NOT EXECUTED 10bfab: 46 inc %esi <== NOT EXECUTED if ( information->is_string ) { 10bfac: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bfaf: 80 7b 38 00 cmpb $0x0,0x38(%ebx) <== NOT EXECUTED 10bfb3: 74 56 je 10c00b <_Objects_Set_name+0x7f> <== NOT EXECUTED char *d; d = _Workspace_Allocate( length ); 10bfb5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bfb8: 56 push %esi <== NOT EXECUTED 10bfb9: e8 4f 16 00 00 call 10d60d <_Workspace_Allocate> <== NOT EXECUTED 10bfbe: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !d ) 10bfc0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bfc3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10bfc5: 85 db test %ebx,%ebx <== NOT EXECUTED 10bfc7: 0f 84 81 00 00 00 je 10c04e <_Objects_Set_name+0xc2> <== NOT EXECUTED return FALSE; if ( the_object->name.name_p ) { 10bfcd: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10bfd0: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10bfd3: 85 c0 test %eax,%eax <== NOT EXECUTED 10bfd5: 74 16 je 10bfed <_Objects_Set_name+0x61> <== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10bfd7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bfda: 50 push %eax <== NOT EXECUTED 10bfdb: e8 18 16 00 00 call 10d5f8 <_Workspace_Free> <== NOT EXECUTED the_object->name.name_p = NULL; 10bfe0: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10bfe3: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) <== NOT EXECUTED 10bfea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } strncpy( d, name, length ); 10bfed: 50 push %eax <== NOT EXECUTED 10bfee: 56 push %esi <== NOT EXECUTED 10bfef: 57 push %edi <== NOT EXECUTED 10bff0: 53 push %ebx <== NOT EXECUTED 10bff1: e8 06 56 00 00 call 1115fc <== NOT EXECUTED d[ length ] = '\0'; 10bff6: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10bff9: c6 44 13 01 00 movb $0x0,0x1(%ebx,%edx,1) <== NOT EXECUTED the_object->name.name_p = d; 10bffe: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c001: 89 58 0c mov %ebx,0xc(%eax) <== NOT EXECUTED 10c004: b0 01 mov $0x1,%al <== NOT EXECUTED 10c006: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c009: eb 43 jmp 10c04e <_Objects_Set_name+0xc2> <== NOT EXECUTED } else { the_object->name.name_u32 = _Objects_Build_name( 10c00b: b8 00 00 00 20 mov $0x20000000,%eax <== NOT EXECUTED 10c010: 85 f6 test %esi,%esi <== NOT EXECUTED 10c012: 74 4e je 10c062 <_Objects_Set_name+0xd6> <== NOT EXECUTED 10c014: 0f be 07 movsbl (%edi),%eax <== NOT EXECUTED 10c017: c1 e0 18 shl $0x18,%eax <== NOT EXECUTED 10c01a: 83 fe 01 cmp $0x1,%esi <== NOT EXECUTED 10c01d: 74 43 je 10c062 <_Objects_Set_name+0xd6> <== NOT EXECUTED 10c01f: 0f be 5f 01 movsbl 0x1(%edi),%ebx <== NOT EXECUTED 10c023: c1 e3 10 shl $0x10,%ebx <== NOT EXECUTED 10c026: 83 fe 02 cmp $0x2,%esi <== NOT EXECUTED 10c029: 76 2b jbe 10c056 <_Objects_Set_name+0xca> <== NOT EXECUTED 10c02b: 0f be 57 02 movsbl 0x2(%edi),%edx <== NOT EXECUTED 10c02f: c1 e2 08 shl $0x8,%edx <== NOT EXECUTED 10c032: b9 20 00 00 00 mov $0x20,%ecx <== NOT EXECUTED 10c037: 83 fe 03 cmp $0x3,%esi <== NOT EXECUTED 10c03a: 76 04 jbe 10c040 <_Objects_Set_name+0xb4> <== NOT EXECUTED 10c03c: 0f be 4f 03 movsbl 0x3(%edi),%ecx <== NOT EXECUTED 10c040: 09 d8 or %ebx,%eax <== NOT EXECUTED 10c042: 09 d0 or %edx,%eax <== NOT EXECUTED 10c044: 09 c8 or %ecx,%eax <== NOT EXECUTED 10c046: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10c049: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED 10c04c: b0 01 mov $0x1,%al <== NOT EXECUTED ); } return TRUE; } 10c04e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c051: 5b pop %ebx <== NOT EXECUTED 10c052: 5e pop %esi <== NOT EXECUTED 10c053: 5f pop %edi <== NOT EXECUTED 10c054: c9 leave <== NOT EXECUTED 10c055: c3 ret <== NOT EXECUTED strncpy( d, name, length ); d[ length ] = '\0'; the_object->name.name_p = d; } else { the_object->name.name_u32 = _Objects_Build_name( 10c056: b9 20 00 00 00 mov $0x20,%ecx <== NOT EXECUTED 10c05b: ba 00 20 00 00 mov $0x2000,%edx <== NOT EXECUTED 10c060: eb de jmp 10c040 <_Objects_Set_name+0xb4> <== NOT EXECUTED 10c062: bb 00 00 20 00 mov $0x200000,%ebx <== NOT EXECUTED 10c067: eb ed jmp 10c056 <_Objects_Set_name+0xca> <== NOT EXECUTED 0010a7bc <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 10a7bc: 55 push %ebp <== NOT EXECUTED 10a7bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a7bf: 57 push %edi <== NOT EXECUTED 10a7c0: 56 push %esi <== NOT EXECUTED 10a7c1: 53 push %ebx <== NOT EXECUTED 10a7c2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a7c5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 10a7c8: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10a7cb: 0f b7 f8 movzwl %ax,%edi <== NOT EXECUTED /* * Search the list to find block or chunnk with all objects inactive. */ index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; 10a7ce: 8b 4e 14 mov 0x14(%esi),%ecx <== NOT EXECUTED 10a7d1: 0f b7 46 10 movzwl 0x10(%esi),%eax <== NOT EXECUTED 10a7d5: 29 f8 sub %edi,%eax <== NOT EXECUTED 10a7d7: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a7d9: f7 f1 div %ecx <== NOT EXECUTED 10a7db: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10a7dd: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a7df: eb 7c jmp 10a85d <_Objects_Shrink_information+0xa1> <== NOT EXECUTED for ( block = 0; block < block_count; block++ ) { 10a7e1: 8d 04 95 00 00 00 00 lea 0x0(,%edx,4),%eax <== NOT EXECUTED 10a7e8: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED if ( information->inactive_per_block[ block ] == information->allocation_size ) { 10a7eb: 8b 46 30 mov 0x30(%esi),%eax <== NOT EXECUTED 10a7ee: 39 0c 90 cmp %ecx,(%eax,%edx,4) <== NOT EXECUTED 10a7f1: 75 67 jne 10a85a <_Objects_Shrink_information+0x9e> <== NOT EXECUTED /* * XXX - Not to sure how to use a chain where you need to iterate and * and remove elements. */ the_object = (Objects_Control *) information->Inactive.first; 10a7f3: 8b 56 20 mov 0x20(%esi),%edx <== NOT EXECUTED 10a7f6: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10a7f9: 0f b7 c8 movzwl %ax,%ecx <== NOT EXECUTED */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 10a7fc: 39 f9 cmp %edi,%ecx <== NOT EXECUTED 10a7fe: 72 1b jb 10a81b <_Objects_Shrink_information+0x5f> <== NOT EXECUTED 10a800: 89 f8 mov %edi,%eax <== NOT EXECUTED 10a802: 03 46 14 add 0x14(%esi),%eax <== NOT EXECUTED 10a805: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10a807: 73 12 jae 10a81b <_Objects_Shrink_information+0x5f> <== NOT EXECUTED * @param[in] start_address is the starting address of the user block * to free * @return TRUE if successfully freed, FALSE otherwise */ bool _Protected_heap_Free( Heap_Control *the_heap, 10a809: 8b 1a mov (%edx),%ebx <== NOT EXECUTED if ( !_Chain_Is_last( &the_object->Node ) ) the_object = (Objects_Control *) the_object->Node.next; else the_object = NULL; _Chain_Extract( &extract_me->Node ); 10a80b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a80e: 52 push %edx <== NOT EXECUTED 10a80f: e8 3c 2e 00 00 call 10d650 <_Chain_Extract> <== NOT EXECUTED 10a814: 89 da mov %ebx,%edx <== NOT EXECUTED 10a816: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a819: eb 02 jmp 10a81d <_Objects_Shrink_information+0x61> <== NOT EXECUTED } else { the_object = (Objects_Control *) the_object->Node.next; 10a81b: 8b 12 mov (%edx),%edx <== NOT EXECUTED } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 10a81d: 85 d2 test %edx,%edx <== NOT EXECUTED 10a81f: 74 05 je 10a826 <_Objects_Shrink_information+0x6a> <== NOT EXECUTED 10a821: 83 3a 00 cmpl $0x0,(%edx) <== NOT EXECUTED 10a824: 75 d0 jne 10a7f6 <_Objects_Shrink_information+0x3a> <== NOT EXECUTED /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); 10a826: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a829: 8b 46 34 mov 0x34(%esi),%eax <== NOT EXECUTED 10a82c: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10a82f: ff 34 10 pushl (%eax,%edx,1) <== NOT EXECUTED 10a832: e8 11 15 00 00 call 10bd48 <_Workspace_Free> <== NOT EXECUTED information->object_blocks[ block ] = NULL; 10a837: 8b 46 34 mov 0x34(%esi),%eax <== NOT EXECUTED 10a83a: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10a83d: c7 04 10 00 00 00 00 movl $0x0,(%eax,%edx,1) <== NOT EXECUTED information->inactive_per_block[ block ] = 0; 10a844: 8b 46 30 mov 0x30(%esi),%eax <== NOT EXECUTED 10a847: c7 04 10 00 00 00 00 movl $0x0,(%eax,%edx,1) <== NOT EXECUTED information->inactive -= information->allocation_size; 10a84e: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED 10a851: 66 29 46 2c sub %ax,0x2c(%esi) <== NOT EXECUTED 10a855: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a858: eb 07 jmp 10a861 <_Objects_Shrink_information+0xa5> <== NOT EXECUTED return; } index_base += information->allocation_size; 10a85a: 01 cf add %ecx,%edi <== NOT EXECUTED */ index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { 10a85c: 42 inc %edx <== NOT EXECUTED 10a85d: 39 da cmp %ebx,%edx <== NOT EXECUTED 10a85f: 72 80 jb 10a7e1 <_Objects_Shrink_information+0x25> <== NOT EXECUTED return; } index_base += information->allocation_size; } } 10a861: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a864: 5b pop %ebx <== NOT EXECUTED 10a865: 5e pop %esi <== NOT EXECUTED 10a866: 5f pop %edi <== NOT EXECUTED 10a867: c9 leave <== NOT EXECUTED 10a868: c3 ret <== NOT EXECUTED 0010d2d0 <_Partition_Manager_initialization>: */ void _Partition_Manager_initialization( uint32_t maximum_partitions ) { 10d2d0: 55 push %ebp <== NOT EXECUTED 10d2d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d2d3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d2d6: 6a 04 push $0x4 <== NOT EXECUTED 10d2d8: 6a 00 push $0x0 <== NOT EXECUTED 10d2da: 6a 30 push $0x30 <== NOT EXECUTED 10d2dc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d2df: 6a 05 push $0x5 <== NOT EXECUTED 10d2e1: 6a 02 push $0x2 <== NOT EXECUTED 10d2e3: 68 b4 cd 11 00 push $0x11cdb4 <== NOT EXECUTED 10d2e8: e8 6b d3 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 10d2ed: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_PARTITION, _Partition_MP_Process_packet ); #endif } 10d2f0: c9 leave <== NOT EXECUTED 10d2f1: c3 ret <== NOT EXECUTED 0010a86c <_Protected_heap_Allocate>: void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ) { 10a86c: 55 push %ebp <== NOT EXECUTED 10a86d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a86f: 53 push %ebx <== NOT EXECUTED 10a870: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED void *p; _RTEMS_Lock_allocator(); 10a873: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 10a879: e8 2e f1 ff ff call 1099ac <_API_Mutex_Lock> <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 10a87e: 5a pop %edx <== NOT EXECUTED 10a87f: 59 pop %ecx <== NOT EXECUTED 10a880: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a883: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a886: e8 11 30 00 00 call 10d89c <_Heap_Allocate> <== NOT EXECUTED 10a88b: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10a88d: 58 pop %eax <== NOT EXECUTED 10a88e: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 10a894: e8 5b f1 ff ff call 1099f4 <_API_Mutex_Unlock> <== NOT EXECUTED return p; } 10a899: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a89b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a89e: c9 leave <== NOT EXECUTED 10a89f: c3 ret <== NOT EXECUTED 0010c570 <_Protected_heap_Allocate_aligned>: void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ) { 10c570: 55 push %ebp <== NOT EXECUTED 10c571: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c573: 53 push %ebx <== NOT EXECUTED 10c574: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED void *p; _RTEMS_Lock_allocator(); 10c577: ff 35 e4 09 12 00 pushl 0x1209e4 <== NOT EXECUTED 10c57d: e8 9a eb ff ff call 10b11c <_API_Mutex_Lock> <== NOT EXECUTED p = _Heap_Allocate_aligned( the_heap, size, alignment ); 10c582: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c585: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10c588: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c58b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c58e: e8 99 f1 ff ff call 10b72c <_Heap_Allocate_aligned> <== NOT EXECUTED 10c593: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10c595: 58 pop %eax <== NOT EXECUTED 10c596: ff 35 e4 09 12 00 pushl 0x1209e4 <== NOT EXECUTED 10c59c: e8 c3 eb ff ff call 10b164 <_API_Mutex_Unlock> <== NOT EXECUTED return p; } 10c5a1: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c5a3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c5a6: c9 leave <== NOT EXECUTED 10c5a7: c3 ret <== NOT EXECUTED 0010c5dc <_Protected_heap_Extend>: bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ) { 10c5dc: 55 push %ebp <== NOT EXECUTED 10c5dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c5df: 53 push %ebx <== NOT EXECUTED 10c5e0: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 10c5e3: ff 35 e4 09 12 00 pushl 0x1209e4 <== NOT EXECUTED 10c5e9: e8 2e eb ff ff call 10b11c <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 10c5ee: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10c5f1: 50 push %eax <== NOT EXECUTED 10c5f2: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10c5f5: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c5f8: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c5fb: e8 74 32 00 00 call 10f874 <_Heap_Extend> <== NOT EXECUTED 10c600: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10c602: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10c605: ff 35 e4 09 12 00 pushl 0x1209e4 <== NOT EXECUTED 10c60b: e8 54 eb ff ff call 10b164 <_API_Mutex_Unlock> <== NOT EXECUTED 10c610: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c613: 85 db test %ebx,%ebx <== NOT EXECUTED 10c615: 0f 94 c0 sete %al <== NOT EXECUTED return (status == HEAP_EXTEND_SUCCESSFUL); } 10c618: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c61b: c9 leave <== NOT EXECUTED 10c61c: c3 ret <== NOT EXECUTED 0010a8a0 <_Protected_heap_Free>: bool _Protected_heap_Free( Heap_Control *the_heap, void *start_address ) { 10a8a0: 55 push %ebp <== NOT EXECUTED 10a8a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a8a3: 53 push %ebx <== NOT EXECUTED 10a8a4: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED bool status; _RTEMS_Lock_allocator(); 10a8a7: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 10a8ad: e8 fa f0 ff ff call 1099ac <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 10a8b2: 5a pop %edx <== NOT EXECUTED 10a8b3: 59 pop %ecx <== NOT EXECUTED 10a8b4: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a8b7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a8ba: e8 49 30 00 00 call 10d908 <_Heap_Free> <== NOT EXECUTED 10a8bf: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10a8c1: 58 pop %eax <== NOT EXECUTED 10a8c2: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 10a8c8: e8 27 f1 ff ff call 1099f4 <_API_Mutex_Unlock> <== NOT EXECUTED return status; } 10a8cd: 88 d8 mov %bl,%al <== NOT EXECUTED 10a8cf: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a8d2: c9 leave <== NOT EXECUTED 10a8d3: c3 ret <== NOT EXECUTED 00114f64 <_Protected_heap_Get_block_size>: bool _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ) { 114f64: 55 push %ebp <== NOT EXECUTED 114f65: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114f67: 53 push %ebx <== NOT EXECUTED 114f68: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED bool status; _RTEMS_Lock_allocator(); 114f6b: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 114f71: e8 36 4a ff ff call 1099ac <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 114f76: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 114f79: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 114f7c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 114f7f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114f82: e8 4d 02 00 00 call 1151d4 <_Heap_Size_of_user_area> <== NOT EXECUTED 114f87: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 114f89: 58 pop %eax <== NOT EXECUTED 114f8a: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 114f90: e8 5f 4a ff ff call 1099f4 <_API_Mutex_Unlock> <== NOT EXECUTED return status; } 114f95: 88 d8 mov %bl,%al <== NOT EXECUTED 114f97: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114f9a: c9 leave <== NOT EXECUTED 114f9b: c3 ret <== NOT EXECUTED 0010f3dc <_Protected_heap_Get_free_information>: bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 10f3dc: 55 push %ebp <== NOT EXECUTED 10f3dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f3df: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED /* * TBD: _Heap_Get_free_information does not error check or return status. */ _RTEMS_Lock_allocator(); 10f3e2: ff 35 ac 9c 15 00 pushl 0x159cac <== NOT EXECUTED 10f3e8: e8 d3 ec ff ff call 10e0c0 <_API_Mutex_Lock> <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 10f3ed: 5a pop %edx <== NOT EXECUTED 10f3ee: 59 pop %ecx <== NOT EXECUTED 10f3ef: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10f3f2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f3f5: e8 6a 27 01 00 call 121b64 <_Heap_Get_free_information> <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10f3fa: 58 pop %eax <== NOT EXECUTED 10f3fb: ff 35 ac 9c 15 00 pushl 0x159cac <== NOT EXECUTED 10f401: e8 02 ed ff ff call 10e108 <_API_Mutex_Unlock> <== NOT EXECUTED return true; } 10f406: b0 01 mov $0x1,%al <== NOT EXECUTED 10f408: c9 leave <== NOT EXECUTED 10f409: c3 ret <== NOT EXECUTED 00121e34 <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 121e34: 55 push %ebp <== NOT EXECUTED 121e35: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121e37: 56 push %esi <== NOT EXECUTED 121e38: 53 push %ebx <== NOT EXECUTED 121e39: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 121e3c: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Heap_Get_information_status status; if ( !the_heap ) 121e3f: 85 f6 test %esi,%esi <== NOT EXECUTED 121e41: 74 33 je 121e76 <_Protected_heap_Get_information+0x42> <== NOT EXECUTED return false; if ( !the_info ) 121e43: 85 db test %ebx,%ebx <== NOT EXECUTED 121e45: 74 2f je 121e76 <_Protected_heap_Get_information+0x42> <== NOT EXECUTED return false; _RTEMS_Lock_allocator(); 121e47: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 121e4a: ff 35 ac 9c 15 00 pushl 0x159cac <== NOT EXECUTED 121e50: e8 6b c2 fe ff call 10e0c0 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Get_information( the_heap, the_info ); 121e55: 5a pop %edx <== NOT EXECUTED 121e56: 59 pop %ecx <== NOT EXECUTED 121e57: 53 push %ebx <== NOT EXECUTED 121e58: 56 push %esi <== NOT EXECUTED 121e59: e8 8a 78 00 00 call 1296e8 <_Heap_Get_information> <== NOT EXECUTED 121e5e: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 121e60: 58 pop %eax <== NOT EXECUTED 121e61: ff 35 ac 9c 15 00 pushl 0x159cac <== NOT EXECUTED 121e67: e8 9c c2 fe ff call 10e108 <_API_Mutex_Unlock> <== NOT EXECUTED if ( status == HEAP_GET_INFORMATION_SUCCESSFUL ) 121e6c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121e6f: 85 db test %ebx,%ebx <== NOT EXECUTED 121e71: 0f 94 c0 sete %al <== NOT EXECUTED 121e74: eb 02 jmp 121e78 <_Protected_heap_Get_information+0x44> <== NOT EXECUTED 121e76: 31 c0 xor %eax,%eax <== NOT EXECUTED return true; return false; } 121e78: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 121e7b: 5b pop %ebx <== NOT EXECUTED 121e7c: 5e pop %esi <== NOT EXECUTED 121e7d: c9 leave <== NOT EXECUTED 121e7e: c3 ret <== NOT EXECUTED 00114f9c <_Protected_heap_Resize_block>: bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ) { 114f9c: 55 push %ebp <== NOT EXECUTED 114f9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114f9f: 53 push %ebx <== NOT EXECUTED 114fa0: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Heap_Resize_status status; uint32_t old_mem_size; uint32_t avail_mem_size; _RTEMS_Lock_allocator(); 114fa3: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 114fa9: e8 fe 49 ff ff call 1099ac <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Resize_block( 114fae: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 114fb1: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 114fb4: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 114fb7: 50 push %eax <== NOT EXECUTED 114fb8: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 114fbb: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 114fbe: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114fc1: e8 1e 00 00 00 call 114fe4 <_Heap_Resize_block> <== NOT EXECUTED 114fc6: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_heap, starting_address, size, &old_mem_size, &avail_mem_size ); _RTEMS_Unlock_allocator(); 114fc8: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 114fcb: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 114fd1: e8 1e 4a ff ff call 1099f4 <_API_Mutex_Unlock> <== NOT EXECUTED 114fd6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114fd9: 85 db test %ebx,%ebx <== NOT EXECUTED 114fdb: 0f 94 c0 sete %al <== NOT EXECUTED return (status == HEAP_RESIZE_SUCCESSFUL); } 114fde: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114fe1: c9 leave <== NOT EXECUTED 114fe2: c3 ret <== NOT EXECUTED 0010c750 <_Protected_heap_Walk>: bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 10c750: 55 push %ebp <== NOT EXECUTED 10c751: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c753: 57 push %edi <== NOT EXECUTED 10c754: 56 push %esi <== NOT EXECUTED 10c755: 53 push %ebx <== NOT EXECUTED 10c756: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c759: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10c75c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10c75f: 8a 5d 10 mov 0x10(%ebp),%bl <== NOT EXECUTED * then it is forbidden to lock a mutex. But since we are inside * a critical section, it should be safe to walk it unlocked. * * NOTE: Dispatching is also disabled during initialization. */ if ( !_Thread_Dispatch_disable_level ) { 10c762: a1 2c 09 12 00 mov 0x12092c,%eax <== NOT EXECUTED 10c767: 85 c0 test %eax,%eax <== NOT EXECUTED 10c769: 75 37 jne 10c7a2 <_Protected_heap_Walk+0x52> <== NOT EXECUTED _RTEMS_Lock_allocator(); 10c76b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c76e: ff 35 e4 09 12 00 pushl 0x1209e4 <== NOT EXECUTED 10c774: e8 a3 e9 ff ff call 10b11c <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Walk( the_heap, source, do_dump ); 10c779: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c77c: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10c77f: 50 push %eax <== NOT EXECUTED 10c780: 56 push %esi <== NOT EXECUTED 10c781: 57 push %edi <== NOT EXECUTED 10c782: e8 a5 32 00 00 call 10fa2c <_Heap_Walk> <== NOT EXECUTED 10c787: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10c789: 58 pop %eax <== NOT EXECUTED 10c78a: ff 35 e4 09 12 00 pushl 0x1209e4 <== NOT EXECUTED 10c790: e8 cf e9 ff ff call 10b164 <_API_Mutex_Unlock> <== NOT EXECUTED 10c795: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { status = _Heap_Walk( the_heap, source, do_dump ); } return status; } 10c798: 88 d8 mov %bl,%al <== NOT EXECUTED 10c79a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c79d: 5b pop %ebx <== NOT EXECUTED 10c79e: 5e pop %esi <== NOT EXECUTED 10c79f: 5f pop %edi <== NOT EXECUTED 10c7a0: c9 leave <== NOT EXECUTED 10c7a1: c3 ret <== NOT EXECUTED if ( !_Thread_Dispatch_disable_level ) { _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 10c7a2: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10c7a5: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 10c7a8: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10c7ab: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED } return status; } 10c7ae: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c7b1: 5b pop %ebx <== NOT EXECUTED 10c7b2: 5e pop %esi <== NOT EXECUTED 10c7b3: 5f pop %edi <== NOT EXECUTED 10c7b4: c9 leave <== NOT EXECUTED if ( !_Thread_Dispatch_disable_level ) { _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 10c7b5: e9 72 32 00 00 jmp 10fa2c <_Heap_Walk> <== NOT EXECUTED 00109810 <_RTEMS_API_Initialize>: */ void _RTEMS_API_Initialize( rtems_configuration_table *configuration_table ) { 109810: 55 push %ebp <== NOT EXECUTED 109811: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109813: 53 push %ebx <== NOT EXECUTED 109814: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED rtems_api_configuration_table *api_configuration; api_configuration = configuration_table->RTEMS_api_configuration; 109817: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10981a: 8b 58 40 mov 0x40(%eax),%ebx <== NOT EXECUTED _Objects_Information_table[OBJECTS_CLASSIC_API] = _RTEMS_Objects; 10981d: c7 05 dc c9 11 00 30 movl $0x11cc30,0x11c9dc <== NOT EXECUTED 109824: cc 11 00 <== NOT EXECUTED _Attributes_Handler_initialization(); _Interrupt_Manager_initialization(); 109827: e8 74 3a 00 00 call 10d2a0 <_Interrupt_Manager_initialization> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) _Multiprocessing_Manager_initialization(); #endif _RTEMS_tasks_Manager_initialization( api_configuration->maximum_tasks ); 10982c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10982f: ff 33 pushl (%ebx) <== NOT EXECUTED 109831: e8 d9 3b 00 00 call 10d40f <_RTEMS_tasks_Manager_initialization> <== NOT EXECUTED _Timer_Manager_initialization( api_configuration->maximum_timers ); 109836: 58 pop %eax <== NOT EXECUTED 109837: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10983a: e8 05 3b 00 00 call 10d344 <_Timer_Manager_initialization> <== NOT EXECUTED _Signal_Manager_initialization(); 10983f: e8 5c 3b 00 00 call 10d3a0 <_Signal_Manager_initialization> <== NOT EXECUTED _Event_Manager_initialization(); 109844: e8 47 3a 00 00 call 10d290 <_Event_Manager_initialization> <== NOT EXECUTED _Message_queue_Manager_initialization( 109849: 58 pop %eax <== NOT EXECUTED 10984a: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10984d: e8 56 3a 00 00 call 10d2a8 <_Message_queue_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_message_queues ); _Semaphore_Manager_initialization( api_configuration->maximum_semaphores ); 109852: 58 pop %eax <== NOT EXECUTED 109853: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 109856: e8 21 3b 00 00 call 10d37c <_Semaphore_Manager_initialization> <== NOT EXECUTED _Partition_Manager_initialization( api_configuration->maximum_partitions ); 10985b: 58 pop %eax <== NOT EXECUTED 10985c: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 10985f: e8 6c 3a 00 00 call 10d2d0 <_Partition_Manager_initialization> <== NOT EXECUTED _Region_Manager_initialization( api_configuration->maximum_regions ); 109864: 59 pop %ecx <== NOT EXECUTED 109865: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 109868: e8 af 3a 00 00 call 10d31c <_Region_Manager_initialization> <== NOT EXECUTED _Dual_ported_memory_Manager_initialization( api_configuration->maximum_ports); 10986d: 5a pop %edx <== NOT EXECUTED 10986e: ff 73 1c pushl 0x1c(%ebx) <== NOT EXECUTED 109871: e8 f6 39 00 00 call 10d26c <_Dual_ported_memory_Manager_initialization> <== NOT EXECUTED _Rate_monotonic_Manager_initialization( api_configuration->maximum_periods ); 109876: 58 pop %eax <== NOT EXECUTED 109877: ff 73 20 pushl 0x20(%ebx) <== NOT EXECUTED 10987a: e8 75 3a 00 00 call 10d2f4 <_Rate_monotonic_Manager_initialization> <== NOT EXECUTED _Barrier_Manager_initialization( api_configuration->maximum_barriers ); 10987f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109882: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 109885: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 109888: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10988b: c9 leave <== NOT EXECUTED _Dual_ported_memory_Manager_initialization( api_configuration->maximum_ports); _Rate_monotonic_Manager_initialization( api_configuration->maximum_periods ); _Barrier_Manager_initialization( api_configuration->maximum_barriers ); 10988c: e9 b7 39 00 00 jmp 10d248 <_Barrier_Manager_initialization> <== NOT EXECUTED 0010d590 <_RTEMS_Tasks_Invoke_task_variable_dtor>: void _RTEMS_Tasks_Invoke_task_variable_dtor( Thread_Control *the_thread, rtems_task_variable_t *tvp ) { 10d590: 55 push %ebp <== NOT EXECUTED 10d591: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d593: 56 push %esi <== NOT EXECUTED 10d594: 53 push %ebx <== NOT EXECUTED 10d595: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED void (*dtor)(void *); void *value; dtor = tvp->dtor; 10d598: 8b 73 10 mov 0x10(%ebx),%esi <== NOT EXECUTED if (_Thread_Is_executing(the_thread)) { 10d59b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d59e: 3b 05 c0 ca 11 00 cmp 0x11cac0,%eax <== NOT EXECUTED 10d5a4: 75 0c jne 10d5b2 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x22> <== NOT EXECUTED value = *tvp->ptr; 10d5a6: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 10d5a9: 8b 0a mov (%edx),%ecx <== NOT EXECUTED *tvp->ptr = tvp->gval; 10d5ab: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10d5ae: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10d5b0: eb 03 jmp 10d5b5 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x25> <== NOT EXECUTED } else { value = tvp->tval; 10d5b2: 8b 4b 0c mov 0xc(%ebx),%ecx <== NOT EXECUTED } if ( dtor ) 10d5b5: 85 f6 test %esi,%esi <== NOT EXECUTED 10d5b7: 74 09 je 10d5c2 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x32> <== NOT EXECUTED (*dtor)(value); 10d5b9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d5bc: 51 push %ecx <== NOT EXECUTED 10d5bd: ff d6 call *%esi <== NOT EXECUTED 10d5bf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Workspace_Free(tvp); 10d5c2: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 10d5c5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d5c8: 5b pop %ebx <== NOT EXECUTED 10d5c9: 5e pop %esi <== NOT EXECUTED 10d5ca: c9 leave <== NOT EXECUTED } if ( dtor ) (*dtor)(value); _Workspace_Free(tvp); 10d5cb: e9 78 e7 ff ff jmp 10bd48 <_Workspace_Free> <== NOT EXECUTED 0010d4ff <_RTEMS_tasks_Create_extension>: bool _RTEMS_tasks_Create_extension( Thread_Control *executing, Thread_Control *created ) { 10d4ff: 55 push %ebp <== NOT EXECUTED 10d500: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d502: 53 push %ebx <== NOT EXECUTED 10d503: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10d506: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED /* * Notepads must be the last entry in the structure and they * can be left off if disabled in the configuration. */ to_allocate = sizeof( RTEMS_API_Control ); if ( !rtems_configuration_get_notepads_enabled() ) 10d509: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 10d50e: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10d511: 80 78 04 01 cmpb $0x1,0x4(%eax) <== NOT EXECUTED 10d515: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10d517: 83 e0 c0 and $0xffffffc0,%eax <== NOT EXECUTED 10d51a: 83 c0 60 add $0x60,%eax <== NOT EXECUTED to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); 10d51d: 50 push %eax <== NOT EXECUTED 10d51e: e8 3a e8 ff ff call 10bd5d <_Workspace_Allocate> <== NOT EXECUTED 10d523: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !api ) 10d525: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d528: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d52a: 85 d2 test %edx,%edx <== NOT EXECUTED 10d52c: 74 5d je 10d58b <_RTEMS_tasks_Create_extension+0x8c> <== NOT EXECUTED return false; created->API_Extensions[ THREAD_API_RTEMS ] = api; 10d52e: 89 93 f4 00 00 00 mov %edx,0xf4(%ebx) <== NOT EXECUTED api->pending_events = EVENT_SETS_NONE_PENDING; 10d534: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of 10d53a: c6 42 08 01 movb $0x1,0x8(%edx) <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of 10d53e: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) <== NOT EXECUTED * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 10d545: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED * 10d54c: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10d553: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10d55a: c7 42 1c 00 00 00 00 movl $0x0,0x1c(%edx) <== NOT EXECUTED _ASR_Initialize( &api->Signal ); created->task_variables = NULL; 10d561: c7 83 04 01 00 00 00 movl $0x0,0x104(%ebx) <== NOT EXECUTED 10d568: 00 00 00 <== NOT EXECUTED if ( rtems_configuration_get_notepads_enabled() ) { 10d56b: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 10d570: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10d573: 80 78 04 00 cmpb $0x0,0x4(%eax) <== NOT EXECUTED 10d577: 74 10 je 10d589 <_RTEMS_tasks_Create_extension+0x8a> <== NOT EXECUTED 10d579: 31 c0 xor %eax,%eax <== NOT EXECUTED for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; 10d57b: c7 44 82 20 00 00 00 movl $0x0,0x20(%edx,%eax,4) <== NOT EXECUTED 10d582: 00 <== NOT EXECUTED api->pending_events = EVENT_SETS_NONE_PENDING; _ASR_Initialize( &api->Signal ); created->task_variables = NULL; if ( rtems_configuration_get_notepads_enabled() ) { for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) 10d583: 40 inc %eax <== NOT EXECUTED 10d584: 83 f8 10 cmp $0x10,%eax <== NOT EXECUTED 10d587: 75 f2 jne 10d57b <_RTEMS_tasks_Create_extension+0x7c> <== NOT EXECUTED 10d589: b0 01 mov $0x1,%al <== NOT EXECUTED api->Notepads[i] = 0; } return true; } 10d58b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d58e: c9 leave <== NOT EXECUTED 10d58f: c3 ret <== NOT EXECUTED 0010d4af <_RTEMS_tasks_Delete_extension>: User_extensions_routine _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 10d4af: 55 push %ebp <== NOT EXECUTED 10d4b0: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d4b2: 56 push %esi <== NOT EXECUTED 10d4b3: 53 push %ebx <== NOT EXECUTED 10d4b4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Free per task variable memory */ tvp = deleted->task_variables; 10d4b7: 8b 86 04 01 00 00 mov 0x104(%esi),%eax <== NOT EXECUTED deleted->task_variables = NULL; 10d4bd: c7 86 04 01 00 00 00 movl $0x0,0x104(%esi) <== NOT EXECUTED 10d4c4: 00 00 00 <== NOT EXECUTED 10d4c7: eb 10 jmp 10d4d9 <_RTEMS_tasks_Delete_extension+0x2a> <== NOT EXECUTED while (tvp) { next = (rtems_task_variable_t *)tvp->next; 10d4c9: 8b 18 mov (%eax),%ebx <== NOT EXECUTED _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); 10d4cb: 52 push %edx <== NOT EXECUTED 10d4cc: 52 push %edx <== NOT EXECUTED 10d4cd: 50 push %eax <== NOT EXECUTED 10d4ce: 56 push %esi <== NOT EXECUTED 10d4cf: e8 bc 00 00 00 call 10d590 <_RTEMS_Tasks_Invoke_task_variable_dtor> <== NOT EXECUTED 10d4d4: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10d4d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 10d4d9: 85 c0 test %eax,%eax <== NOT EXECUTED 10d4db: 75 ec jne 10d4c9 <_RTEMS_tasks_Delete_extension+0x1a> <== NOT EXECUTED /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); 10d4dd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d4e0: ff b6 f4 00 00 00 pushl 0xf4(%esi) <== NOT EXECUTED 10d4e6: e8 5d e8 ff ff call 10bd48 <_Workspace_Free> <== NOT EXECUTED deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 10d4eb: c7 86 f4 00 00 00 00 movl $0x0,0xf4(%esi) <== NOT EXECUTED 10d4f2: 00 00 00 <== NOT EXECUTED 10d4f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10d4f8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d4fb: 5b pop %ebx <== NOT EXECUTED 10d4fc: 5e pop %esi <== NOT EXECUTED 10d4fd: c9 leave <== NOT EXECUTED 10d4fe: c3 ret <== NOT EXECUTED 0010d3fd <_RTEMS_tasks_Initialize_user_tasks>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks( void ) { 10d3fd: 55 push %ebp <== NOT EXECUTED 10d3fe: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( _RTEMS_tasks_Initialize_user_tasks_p ) 10d400: 8b 0d d4 86 11 00 mov 0x1186d4,%ecx <== NOT EXECUTED 10d406: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10d408: 74 03 je 10d40d <_RTEMS_tasks_Initialize_user_tasks+0x10> <== NOT EXECUTED (*_RTEMS_tasks_Initialize_user_tasks_p)(); } 10d40a: c9 leave <== NOT EXECUTED */ void _RTEMS_tasks_Initialize_user_tasks( void ) { if ( _RTEMS_tasks_Initialize_user_tasks_p ) (*_RTEMS_tasks_Initialize_user_tasks_p)(); 10d40b: ff e1 jmp *%ecx <== NOT EXECUTED } 10d40d: c9 leave <== NOT EXECUTED 10d40e: c3 ret <== NOT EXECUTED 001094b8 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 1094b8: 55 push %ebp <== NOT EXECUTED 1094b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1094bb: 57 push %edi <== NOT EXECUTED 1094bc: 56 push %esi <== NOT EXECUTED 1094bd: 53 push %ebx <== NOT EXECUTED 1094be: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED rtems_status_code return_value; rtems_initialization_tasks_table *user_tasks; rtems_api_configuration_table *api_configuration; api_configuration = _Configuration_Table->RTEMS_api_configuration; 1094c1: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 1094c6: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED /* * NOTE: This is slightly different from the Ada implementation. */ user_tasks = api_configuration->User_initialization_tasks_table; 1094c9: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED maximum = api_configuration->number_of_initialization_tasks; 1094cc: 8b 78 28 mov 0x28(%eax),%edi <== NOT EXECUTED if ( !user_tasks || maximum == 0 ) 1094cf: 85 d2 test %edx,%edx <== NOT EXECUTED 1094d1: 74 53 je 109526 <_RTEMS_tasks_Initialize_user_tasks_body+0x6e> <== NOT EXECUTED 1094d3: 85 ff test %edi,%edi <== NOT EXECUTED 1094d5: 74 4f je 109526 <_RTEMS_tasks_Initialize_user_tasks_body+0x6e> <== NOT EXECUTED return; 1094d7: 89 d3 mov %edx,%ebx <== NOT EXECUTED 1094d9: 31 f6 xor %esi,%esi <== NOT EXECUTED 1094db: eb 45 jmp 109522 <_RTEMS_tasks_Initialize_user_tasks_body+0x6a> <== NOT EXECUTED for ( index=0 ; index < maximum ; index++ ) { return_value = rtems_task_create( 1094dd: 50 push %eax <== NOT EXECUTED 1094de: 50 push %eax <== NOT EXECUTED 1094df: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 1094e2: 50 push %eax <== NOT EXECUTED 1094e3: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 1094e6: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 1094e9: ff 73 04 pushl 0x4(%ebx) <== NOT EXECUTED 1094ec: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 1094ef: ff 33 pushl (%ebx) <== NOT EXECUTED 1094f1: e8 ca fd ff ff call 1092c0 <== NOT EXECUTED user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 1094f6: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1094f9: 85 c0 test %eax,%eax <== NOT EXECUTED 1094fb: 75 19 jne 109516 <_RTEMS_tasks_Initialize_user_tasks_body+0x5e> <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); return_value = rtems_task_start( 1094fd: 51 push %ecx <== NOT EXECUTED 1094fe: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 109501: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109504: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 109507: e8 24 00 00 00 call 109530 <== NOT EXECUTED 10950c: 83 c3 1c add $0x1c,%ebx <== NOT EXECUTED id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 10950f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109512: 85 c0 test %eax,%eax <== NOT EXECUTED 109514: 74 0b je 109521 <_RTEMS_tasks_Initialize_user_tasks_body+0x69> <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 109516: 52 push %edx <== NOT EXECUTED 109517: 50 push %eax <== NOT EXECUTED 109518: 6a 01 push $0x1 <== NOT EXECUTED 10951a: 6a 01 push $0x1 <== NOT EXECUTED 10951c: e8 07 0c 00 00 call 10a128 <_Internal_error_Occurred> <== NOT EXECUTED maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) return; for ( index=0 ; index < maximum ; index++ ) { 109521: 46 inc %esi <== NOT EXECUTED 109522: 39 fe cmp %edi,%esi <== NOT EXECUTED 109524: 72 b7 jb 1094dd <_RTEMS_tasks_Initialize_user_tasks_body+0x25> <== NOT EXECUTED ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); } } 109526: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109529: 5b pop %ebx <== NOT EXECUTED 10952a: 5e pop %esi <== NOT EXECUTED 10952b: 5f pop %edi <== NOT EXECUTED 10952c: c9 leave <== NOT EXECUTED 10952d: c3 ret <== NOT EXECUTED 0010d40f <_RTEMS_tasks_Manager_initialization>: */ void _RTEMS_tasks_Manager_initialization( uint32_t maximum_tasks ) { 10d40f: 55 push %ebp <== NOT EXECUTED 10d410: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d412: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d415: 6a 04 push $0x4 <== NOT EXECUTED 10d417: 6a 00 push $0x0 <== NOT EXECUTED 10d419: 68 08 01 00 00 push $0x108 <== NOT EXECUTED 10d41e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d421: 6a 01 push $0x1 <== NOT EXECUTED 10d423: 6a 02 push $0x2 <== NOT EXECUTED 10d425: 68 88 c9 11 00 push $0x11c988 <== NOT EXECUTED 10d42a: e8 29 d2 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED /* * Add all the extensions for this API */ _User_extensions_Add_API_set( &_RTEMS_tasks_User_extensions ); 10d42f: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10d432: 68 84 a9 11 00 push $0x11a984 <== NOT EXECUTED 10d437: e8 c0 09 00 00 call 10ddfc <_User_extensions_Add_API_set> <== NOT EXECUTED _API_extensions_Add( &_RTEMS_tasks_API_extensions ); 10d43c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d43f: c7 45 08 70 a9 11 00 movl $0x11a970,0x8(%ebp) <== NOT EXECUTED MP_PACKET_TASKS, _RTEMS_tasks_MP_Process_packet ); #endif } 10d446: c9 leave <== NOT EXECUTED * Add all the extensions for this API */ _User_extensions_Add_API_set( &_RTEMS_tasks_User_extensions ); _API_extensions_Add( &_RTEMS_tasks_API_extensions ); 10d447: e9 ea c4 ff ff jmp 109936 <_API_extensions_Add> <== NOT EXECUTED 0010d44c <_RTEMS_tasks_Post_switch_extension>: */ void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) { 10d44c: 55 push %ebp <== NOT EXECUTED 10d44d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d44f: 57 push %edi <== NOT EXECUTED 10d450: 56 push %esi <== NOT EXECUTED 10d451: 53 push %ebx <== NOT EXECUTED 10d452: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED RTEMS_API_Control *api; ASR_Information *asr; rtems_signal_set signal_set; Modes_Control prev_mode; api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10d455: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d458: 8b b0 f4 00 00 00 mov 0xf4(%eax),%esi <== NOT EXECUTED if ( !api ) 10d45e: 85 f6 test %esi,%esi <== NOT EXECUTED 10d460: 74 45 je 10d4a7 <_RTEMS_tasks_Post_switch_extension+0x5b> <== NOT EXECUTED * Signal Processing */ asr = &api->Signal; _ISR_Disable( level ); 10d462: 9c pushf <== NOT EXECUTED 10d463: fa cli <== NOT EXECUTED 10d464: 58 pop %eax <== NOT EXECUTED signal_set = asr->signals_posted; 10d465: 8b 7e 14 mov 0x14(%esi),%edi <== NOT EXECUTED asr->signals_posted = 0; 10d468: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED _ISR_Enable( level ); 10d46f: 50 push %eax <== NOT EXECUTED 10d470: 9d popf <== NOT EXECUTED if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 10d471: 85 ff test %edi,%edi <== NOT EXECUTED 10d473: 74 32 je 10d4a7 <_RTEMS_tasks_Post_switch_extension+0x5b> <== NOT EXECUTED return; asr->nest_level += 1; 10d475: ff 46 1c incl 0x1c(%esi) <== NOT EXECUTED rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10d478: 50 push %eax <== NOT EXECUTED 10d479: 8d 5d f0 lea -0x10(%ebp),%ebx <== NOT EXECUTED 10d47c: 53 push %ebx <== NOT EXECUTED 10d47d: 68 ff ff 00 00 push $0xffff <== NOT EXECUTED 10d482: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 10d485: e8 f6 0d 00 00 call 10e280 <== NOT EXECUTED (*asr->handler)( signal_set ); 10d48a: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10d48d: ff 56 0c call *0xc(%esi) <== NOT EXECUTED asr->nest_level -= 1; 10d490: ff 4e 1c decl 0x1c(%esi) <== NOT EXECUTED rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10d493: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10d496: 53 push %ebx <== NOT EXECUTED 10d497: 68 ff ff 00 00 push $0xffff <== NOT EXECUTED 10d49c: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10d49f: e8 dc 0d 00 00 call 10e280 <== NOT EXECUTED 10d4a4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10d4a7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d4aa: 5b pop %ebx <== NOT EXECUTED 10d4ab: 5e pop %esi <== NOT EXECUTED 10d4ac: 5f pop %edi <== NOT EXECUTED 10d4ad: c9 leave <== NOT EXECUTED 10d4ae: c3 ret <== NOT EXECUTED 0010d3a8 <_RTEMS_tasks_Start_extension>: User_extensions_routine _RTEMS_tasks_Start_extension( Thread_Control *executing, Thread_Control *started ) { 10d3a8: 55 push %ebp <== NOT EXECUTED 10d3a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED RTEMS_API_Control *api; api = started->API_Extensions[ THREAD_API_RTEMS ]; api->pending_events = EVENT_SETS_NONE_PENDING; 10d3ab: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10d3ae: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10d3b4: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED } 10d3ba: c9 leave <== NOT EXECUTED 10d3bb: c3 ret <== NOT EXECUTED 0010d3bc <_RTEMS_tasks_Switch_extension>: void _RTEMS_tasks_Switch_extension( Thread_Control *executing, Thread_Control *heir ) { 10d3bc: 55 push %ebp <== NOT EXECUTED 10d3bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED /* * Per Task Variables */ tvp = executing->task_variables; 10d3bf: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d3c2: 8b 88 04 01 00 00 mov 0x104(%eax),%ecx <== NOT EXECUTED 10d3c8: eb 0f jmp 10d3d9 <_RTEMS_tasks_Switch_extension+0x1d> <== NOT EXECUTED while (tvp) { tvp->tval = *tvp->ptr; 10d3ca: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d3cd: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10d3cf: 89 51 0c mov %edx,0xc(%ecx) <== NOT EXECUTED *tvp->ptr = tvp->gval; 10d3d2: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED 10d3d5: 89 10 mov %edx,(%eax) <== NOT EXECUTED tvp = (rtems_task_variable_t *)tvp->next; 10d3d7: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED /* * Per Task Variables */ tvp = executing->task_variables; while (tvp) { 10d3d9: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10d3db: 75 ed jne 10d3ca <_RTEMS_tasks_Switch_extension+0xe> <== NOT EXECUTED tvp->tval = *tvp->ptr; *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; 10d3dd: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10d3e0: 8b 88 04 01 00 00 mov 0x104(%eax),%ecx <== NOT EXECUTED 10d3e6: eb 0f jmp 10d3f7 <_RTEMS_tasks_Switch_extension+0x3b> <== NOT EXECUTED while (tvp) { tvp->gval = *tvp->ptr; 10d3e8: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d3eb: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10d3ed: 89 51 08 mov %edx,0x8(%ecx) <== NOT EXECUTED *tvp->ptr = tvp->tval; 10d3f0: 8b 51 0c mov 0xc(%ecx),%edx <== NOT EXECUTED 10d3f3: 89 10 mov %edx,(%eax) <== NOT EXECUTED tvp = (rtems_task_variable_t *)tvp->next; 10d3f5: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { 10d3f7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10d3f9: 75 ed jne 10d3e8 <_RTEMS_tasks_Switch_extension+0x2c> <== NOT EXECUTED tvp->gval = *tvp->ptr; *tvp->ptr = tvp->tval; tvp = (rtems_task_variable_t *)tvp->next; } } 10d3fb: c9 leave <== NOT EXECUTED 10d3fc: c3 ret <== NOT EXECUTED 00109dac <_Rate_monotonic_Initiate_statistics>: #endif void _Rate_monotonic_Initiate_statistics( Rate_monotonic_Control *the_period ) { 109dac: 55 push %ebp <== NOT EXECUTED 109dad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109daf: 57 push %edi <== NOT EXECUTED 109db0: 56 push %esi <== NOT EXECUTED 109db1: 53 push %ebx <== NOT EXECUTED 109db2: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 109db5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Thread_Control *owning_thread = the_period->owner; 109db8: 8b 5e 50 mov 0x50(%esi),%ebx <== NOT EXECUTED #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) struct timespec uptime; _TOD_Get_uptime( &uptime ); 109dbb: 8d 7d ec lea -0x14(%ebp),%edi <== NOT EXECUTED 109dbe: 57 push %edi <== NOT EXECUTED 109dbf: e8 cc 16 00 00 call 10b490 <_TOD_Get_uptime> <== NOT EXECUTED /* * Set the starting point and the CPU time used for the statistics. */ #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS the_period->time_at_period = uptime; 109dc4: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 109dc7: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 109dca: 89 46 44 mov %eax,0x44(%esi) <== NOT EXECUTED 109dcd: 89 56 48 mov %edx,0x48(%esi) <== NOT EXECUTED #else the_period->time_at_period = _Watchdog_Ticks_since_boot; #endif the_period->owner_executed_at_period = owning_thread->cpu_time_used; 109dd0: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx <== NOT EXECUTED 109dd6: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax <== NOT EXECUTED 109ddc: 89 46 40 mov %eax,0x40(%esi) <== NOT EXECUTED 109ddf: 89 56 3c mov %edx,0x3c(%esi) <== NOT EXECUTED * context switch. When this routine is invoked from * rtems_rate_monotonic_period, the owner will be the executing thread. * When this routine is invoked from _Rate_monotonic_Timeout, it will not. */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS if (owning_thread == _Thread_Executing) { 109de2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109de5: 3b 1d 84 0b 12 00 cmp 0x120b84,%ebx <== NOT EXECUTED 109deb: 75 1f jne 109e0c <_Rate_monotonic_Initiate_statistics+0x60> <== NOT EXECUTED /* * Adjust the CPU time used to account for the time since last * context switch. */ _Timespec_Subtract( 109ded: 51 push %ecx <== NOT EXECUTED 109dee: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED 109df1: 53 push %ebx <== NOT EXECUTED 109df2: 57 push %edi <== NOT EXECUTED 109df3: 68 8c 0b 12 00 push $0x120b8c <== NOT EXECUTED 109df8: e8 d3 33 00 00 call 10d1d0 <_Timespec_Subtract> <== NOT EXECUTED &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timespec_Add_to( &the_period->owner_executed_at_period, &ran ); 109dfd: 58 pop %eax <== NOT EXECUTED 109dfe: 5a pop %edx <== NOT EXECUTED 109dff: 53 push %ebx <== NOT EXECUTED 109e00: 8d 46 3c lea 0x3c(%esi),%eax <== NOT EXECUTED 109e03: 50 push %eax <== NOT EXECUTED 109e04: e8 d3 32 00 00 call 10d0dc <_Timespec_Add_to> <== NOT EXECUTED 109e09: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } #endif } 109e0c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109e0f: 5b pop %ebx <== NOT EXECUTED 109e10: 5e pop %esi <== NOT EXECUTED 109e11: 5f pop %edi <== NOT EXECUTED 109e12: c9 leave <== NOT EXECUTED 109e13: c3 ret <== NOT EXECUTED 0010d2f4 <_Rate_monotonic_Manager_initialization>: */ void _Rate_monotonic_Manager_initialization( uint32_t maximum_periods ) { 10d2f4: 55 push %ebp <== NOT EXECUTED 10d2f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d2f7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d2fa: 6a 04 push $0x4 <== NOT EXECUTED 10d2fc: 6a 00 push $0x0 <== NOT EXECUTED 10d2fe: 68 8c 00 00 00 push $0x8c <== NOT EXECUTED 10d303: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d306: 6a 08 push $0x8 <== NOT EXECUTED 10d308: 6a 02 push $0x2 <== NOT EXECUTED 10d30a: 68 f4 cd 11 00 push $0x11cdf4 <== NOT EXECUTED 10d30f: e8 44 d3 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 10d314: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10d317: c9 leave <== NOT EXECUTED 10d318: c3 ret <== NOT EXECUTED 0010a2e8 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 10a2e8: 55 push %ebp <== NOT EXECUTED 10a2e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a2eb: 53 push %ebx <== NOT EXECUTED 10a2ec: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10a2ef: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a2f2: 50 push %eax <== NOT EXECUTED 10a2f3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a2f6: 68 cc 09 12 00 push $0x1209cc <== NOT EXECUTED 10a2fb: e8 f8 19 00 00 call 10bcf8 <_Objects_Get> <== NOT EXECUTED 10a300: 89 c3 mov %eax,%ebx <== NOT EXECUTED /* * 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 ); switch ( location ) { 10a302: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a305: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10a309: 75 64 jne 10a36f <_Rate_monotonic_Timeout+0x87> <== NOT EXECUTED case OBJECTS_LOCAL: the_thread = the_period->owner; 10a30b: 8b 50 50 mov 0x50(%eax),%edx <== NOT EXECUTED if ( _States_Is_waiting_for_period( the_thread->current_state ) && 10a30e: f6 42 11 40 testb $0x40,0x11(%edx) <== NOT EXECUTED 10a312: 74 18 je 10a32c <_Rate_monotonic_Timeout+0x44> <== NOT EXECUTED 10a314: 8b 42 20 mov 0x20(%edx),%eax <== NOT EXECUTED 10a317: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10a31a: 75 10 jne 10a32c <_Rate_monotonic_Timeout+0x44> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10a31c: 50 push %eax <== NOT EXECUTED 10a31d: 50 push %eax <== NOT EXECUTED 10a31e: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10a323: 52 push %edx <== NOT EXECUTED 10a324: e8 0f 1e 00 00 call 10c138 <_Thread_Clear_state> <== NOT EXECUTED the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 10a329: 59 pop %ecx <== NOT EXECUTED 10a32a: eb 10 jmp 10a33c <_Rate_monotonic_Timeout+0x54> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 10a32c: 83 7b 38 01 cmpl $0x1,0x38(%ebx) <== NOT EXECUTED 10a330: 75 2b jne 10a35d <_Rate_monotonic_Timeout+0x75> <== NOT EXECUTED the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 10a332: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) <== NOT EXECUTED _Rate_monotonic_Initiate_statistics( the_period ); 10a339: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a33c: 53 push %ebx <== NOT EXECUTED 10a33d: e8 6a fa ff ff call 109dac <_Rate_monotonic_Initiate_statistics> <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10a342: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 10a345: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10a348: 58 pop %eax <== NOT EXECUTED 10a349: 5a pop %edx <== NOT EXECUTED 10a34a: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10a34d: 50 push %eax <== NOT EXECUTED 10a34e: 68 a4 0b 12 00 push $0x120ba4 <== NOT EXECUTED 10a353: e8 bc 30 00 00 call 10d414 <_Watchdog_Insert> <== NOT EXECUTED 10a358: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a35b: eb 07 jmp 10a364 <_Rate_monotonic_Timeout+0x7c> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else the_period->state = RATE_MONOTONIC_EXPIRED; 10a35d: c7 43 38 04 00 00 00 movl $0x4,0x38(%ebx) <== NOT EXECUTED 10a364: a1 c4 0a 12 00 mov 0x120ac4,%eax <== NOT EXECUTED 10a369: 48 dec %eax <== NOT EXECUTED 10a36a: a3 c4 0a 12 00 mov %eax,0x120ac4 <== NOT EXECUTED case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10a36f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a372: c9 leave <== NOT EXECUTED 10a373: c3 ret <== NOT EXECUTED 00109e14 <_Rate_monotonic_Update_statistics>: void _Rate_monotonic_Update_statistics( Rate_monotonic_Control *the_period ) { 109e14: 55 push %ebp <== NOT EXECUTED 109e15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109e17: 57 push %edi <== NOT EXECUTED 109e18: 56 push %esi <== NOT EXECUTED 109e19: 53 push %ebx <== NOT EXECUTED 109e1a: 83 ec 48 sub $0x48,%esp <== NOT EXECUTED 109e1d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED struct timespec uptime; /* * Obtain the current time since boot */ _TOD_Get_uptime( &uptime ); 109e20: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 109e23: 50 push %eax <== NOT EXECUTED 109e24: e8 67 16 00 00 call 10b490 <_TOD_Get_uptime> <== NOT EXECUTED /* * Update the counts. */ stats = &the_period->Statistics; stats->count++; 109e29: ff 47 54 incl 0x54(%edi) <== NOT EXECUTED if ( the_period->state == RATE_MONOTONIC_EXPIRED ) 109e2c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109e2f: 83 7f 38 04 cmpl $0x4,0x38(%edi) <== NOT EXECUTED 109e33: 75 03 jne 109e38 <_Rate_monotonic_Update_statistics+0x24> <== NOT EXECUTED stats->missed_count++; 109e35: ff 47 58 incl 0x58(%edi) <== NOT EXECUTED /* * Grab basic information for time statistics. */ #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 109e38: 50 push %eax <== NOT EXECUTED 109e39: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 109e3c: 50 push %eax <== NOT EXECUTED 109e3d: 8d 75 dc lea -0x24(%ebp),%esi <== NOT EXECUTED 109e40: 56 push %esi <== NOT EXECUTED 109e41: 8d 47 44 lea 0x44(%edi),%eax <== NOT EXECUTED 109e44: 50 push %eax <== NOT EXECUTED 109e45: e8 86 33 00 00 call 10d1d0 <_Timespec_Subtract> <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { rtems_thread_cpu_usage_t ran, used; /* Grab CPU usage when the thread got switched in */ used = _Thread_Executing->cpu_time_used; 109e4a: a1 84 0b 12 00 mov 0x120b84,%eax <== NOT EXECUTED 109e4f: 8b 90 84 00 00 00 mov 0x84(%eax),%edx <== NOT EXECUTED 109e55: 8b 80 88 00 00 00 mov 0x88(%eax),%eax <== NOT EXECUTED 109e5b: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 109e5e: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED /* How much time time since last context switch */ _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); 109e61: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 109e64: 8d 5d d4 lea -0x2c(%ebp),%ebx <== NOT EXECUTED 109e67: 53 push %ebx <== NOT EXECUTED 109e68: 56 push %esi <== NOT EXECUTED 109e69: 68 8c 0b 12 00 push $0x120b8c <== NOT EXECUTED 109e6e: e8 5d 33 00 00 call 10d1d0 <_Timespec_Subtract> <== NOT EXECUTED /* executed += ran */ _Timespec_Add_to( &used, &ran ); 109e73: 5e pop %esi <== NOT EXECUTED 109e74: 58 pop %eax <== NOT EXECUTED 109e75: 53 push %ebx <== NOT EXECUTED 109e76: 8d 75 cc lea -0x34(%ebp),%esi <== NOT EXECUTED 109e79: 56 push %esi <== NOT EXECUTED 109e7a: e8 5d 32 00 00 call 10d0dc <_Timespec_Add_to> <== NOT EXECUTED /* partial period, cpu usage info reset while executing. Throw away */ if (_Timespec_Less_than( &used, &the_period->owner_executed_at_period)) 109e7f: 8d 47 3c lea 0x3c(%edi),%eax <== NOT EXECUTED 109e82: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED 109e85: 5a pop %edx <== NOT EXECUTED 109e86: 59 pop %ecx <== NOT EXECUTED 109e87: 50 push %eax <== NOT EXECUTED 109e88: 56 push %esi <== NOT EXECUTED 109e89: e8 1a 33 00 00 call 10d1a8 <_Timespec_Less_than> <== NOT EXECUTED 109e8e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109e91: 84 c0 test %al,%al <== NOT EXECUTED 109e93: 0f 85 b1 00 00 00 jne 109f4a <_Rate_monotonic_Update_statistics+0x136> <== NOT EXECUTED return; /* executed = current cpu usage - value at start of period */ _Timespec_Subtract( 109e99: 50 push %eax <== NOT EXECUTED 109e9a: 8d 5d ec lea -0x14(%ebp),%ebx <== NOT EXECUTED 109e9d: 53 push %ebx <== NOT EXECUTED 109e9e: 56 push %esi <== NOT EXECUTED 109e9f: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED 109ea2: e8 29 33 00 00 call 10d1d0 <_Timespec_Subtract> <== NOT EXECUTED /* * Update CPU time */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _Timespec_Add_to( &stats->total_cpu_time, &executed ); 109ea7: 59 pop %ecx <== NOT EXECUTED 109ea8: 5e pop %esi <== NOT EXECUTED 109ea9: 53 push %ebx <== NOT EXECUTED 109eaa: 8d 47 6c lea 0x6c(%edi),%eax <== NOT EXECUTED 109ead: 50 push %eax <== NOT EXECUTED 109eae: e8 29 32 00 00 call 10d0dc <_Timespec_Add_to> <== NOT EXECUTED if ( _Timespec_Less_than( &executed, &stats->min_cpu_time ) ) 109eb3: 58 pop %eax <== NOT EXECUTED 109eb4: 5a pop %edx <== NOT EXECUTED 109eb5: 8d 47 5c lea 0x5c(%edi),%eax <== NOT EXECUTED 109eb8: 50 push %eax <== NOT EXECUTED 109eb9: 53 push %ebx <== NOT EXECUTED 109eba: e8 e9 32 00 00 call 10d1a8 <_Timespec_Less_than> <== NOT EXECUTED 109ebf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109ec2: 84 c0 test %al,%al <== NOT EXECUTED 109ec4: 74 0c je 109ed2 <_Rate_monotonic_Update_statistics+0xbe> <== NOT EXECUTED stats->min_cpu_time = executed; 109ec6: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 109ec9: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 109ecc: 89 47 5c mov %eax,0x5c(%edi) <== NOT EXECUTED 109ecf: 89 57 60 mov %edx,0x60(%edi) <== NOT EXECUTED if ( _Timespec_Greater_than( &executed, &stats->max_cpu_time ) ) 109ed2: 50 push %eax <== NOT EXECUTED 109ed3: 50 push %eax <== NOT EXECUTED 109ed4: 8d 47 64 lea 0x64(%edi),%eax <== NOT EXECUTED 109ed7: 50 push %eax <== NOT EXECUTED 109ed8: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 109edb: 50 push %eax <== NOT EXECUTED 109edc: e8 9f 32 00 00 call 10d180 <_Timespec_Greater_than> <== NOT EXECUTED 109ee1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109ee4: 84 c0 test %al,%al <== NOT EXECUTED 109ee6: 74 0c je 109ef4 <_Rate_monotonic_Update_statistics+0xe0> <== NOT EXECUTED stats->max_cpu_time = executed; 109ee8: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 109eeb: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 109eee: 89 47 64 mov %eax,0x64(%edi) <== NOT EXECUTED 109ef1: 89 57 68 mov %edx,0x68(%edi) <== NOT EXECUTED stats->min_wall_time = since_last_period; if ( since_last_period > stats->max_wall_time ) stats->max_wall_time = since_last_period; #else _Timespec_Add_to( &stats->total_wall_time, &since_last_period ); 109ef4: 50 push %eax <== NOT EXECUTED 109ef5: 50 push %eax <== NOT EXECUTED 109ef6: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED 109ef9: 53 push %ebx <== NOT EXECUTED 109efa: 8d 87 84 00 00 00 lea 0x84(%edi),%eax <== NOT EXECUTED 109f00: 50 push %eax <== NOT EXECUTED 109f01: e8 d6 31 00 00 call 10d0dc <_Timespec_Add_to> <== NOT EXECUTED if ( _Timespec_Less_than( &since_last_period, &stats->min_wall_time ) ) 109f06: 5e pop %esi <== NOT EXECUTED 109f07: 58 pop %eax <== NOT EXECUTED 109f08: 8d 47 74 lea 0x74(%edi),%eax <== NOT EXECUTED 109f0b: 50 push %eax <== NOT EXECUTED 109f0c: 53 push %ebx <== NOT EXECUTED 109f0d: e8 96 32 00 00 call 10d1a8 <_Timespec_Less_than> <== NOT EXECUTED 109f12: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109f15: 84 c0 test %al,%al <== NOT EXECUTED 109f17: 74 0c je 109f25 <_Rate_monotonic_Update_statistics+0x111> <== NOT EXECUTED stats->min_wall_time = since_last_period; 109f19: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 109f1c: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 109f1f: 89 47 74 mov %eax,0x74(%edi) <== NOT EXECUTED 109f22: 89 57 78 mov %edx,0x78(%edi) <== NOT EXECUTED if ( _Timespec_Greater_than( &since_last_period, &stats->max_wall_time ) ) 109f25: 53 push %ebx <== NOT EXECUTED 109f26: 53 push %ebx <== NOT EXECUTED 109f27: 8d 47 7c lea 0x7c(%edi),%eax <== NOT EXECUTED 109f2a: 50 push %eax <== NOT EXECUTED 109f2b: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 109f2e: 50 push %eax <== NOT EXECUTED 109f2f: e8 4c 32 00 00 call 10d180 <_Timespec_Greater_than> <== NOT EXECUTED 109f34: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109f37: 84 c0 test %al,%al <== NOT EXECUTED 109f39: 74 0f je 109f4a <_Rate_monotonic_Update_statistics+0x136> <== NOT EXECUTED stats->max_wall_time = since_last_period; 109f3b: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 109f3e: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 109f41: 89 47 7c mov %eax,0x7c(%edi) <== NOT EXECUTED 109f44: 89 97 80 00 00 00 mov %edx,0x80(%edi) <== NOT EXECUTED #endif } 109f4a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109f4d: 5b pop %ebx <== NOT EXECUTED 109f4e: 5e pop %esi <== NOT EXECUTED 109f4f: 5f pop %edi <== NOT EXECUTED 109f50: c9 leave <== NOT EXECUTED 109f51: c3 ret <== NOT EXECUTED 0010d31c <_Region_Manager_initialization>: */ void _Region_Manager_initialization( uint32_t maximum_regions ) { 10d31c: 55 push %ebp <== NOT EXECUTED 10d31d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d31f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d322: 6a 04 push $0x4 <== NOT EXECUTED 10d324: 6a 00 push $0x0 <== NOT EXECUTED 10d326: 68 c0 00 00 00 push $0xc0 <== NOT EXECUTED 10d32b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d32e: 6a 06 push $0x6 <== NOT EXECUTED 10d330: 6a 02 push $0x2 <== NOT EXECUTED 10d332: 68 34 ce 11 00 push $0x11ce34 <== NOT EXECUTED 10d337: e8 1c d3 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 10d33c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_REGION, 0 /* XXX _Region_MP_Process_packet */ ); #endif } 10d33f: c9 leave <== NOT EXECUTED 10d340: c3 ret <== NOT EXECUTED 00118080 <_Region_Process_queue>: */ void _Region_Process_queue( Region_Control *the_region ) { 118080: 55 push %ebp <== NOT EXECUTED 118081: 89 e5 mov %esp,%ebp <== NOT EXECUTED 118083: 57 push %edi <== NOT EXECUTED 118084: 56 push %esi <== NOT EXECUTED 118085: 53 push %ebx <== NOT EXECUTED 118086: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 118089: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 11808c: a1 e0 27 13 00 mov 0x1327e0,%eax <== NOT EXECUTED 118091: 40 inc %eax <== NOT EXECUTED 118092: a3 e0 27 13 00 mov %eax,0x1327e0 <== NOT EXECUTED * NOTE: Be sure to disable dispatching before unlocking the mutex * since we do not want to open a window where a context * switch could occur. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); 118097: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 11809d: e8 ea b8 ff ff call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED /* * NOTE: The following loop is O(n) where n is the number of * threads whose memory request is satisfied. */ for ( ; ; ) { the_thread = _Thread_queue_First( &the_region->Wait_queue ); 1180a2: 8d 7e 10 lea 0x10(%esi),%edi <== NOT EXECUTED /** * This function attempts to allocate a block of @a size bytes from * @a the_heap. If insufficient memory is free in @a the_heap to allocate * a block of the requested size, then NULL is returned. * 1180a5: 8d 46 68 lea 0x68(%esi),%eax <== NOT EXECUTED 1180a8: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 1180ab: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 1180ae: e8 dd 06 00 00 call 118790 <_Thread_queue_First> <== NOT EXECUTED 1180b3: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( the_thread == NULL ) 1180b5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1180b8: 85 c0 test %eax,%eax <== NOT EXECUTED 1180ba: 74 30 je 1180ec <_Region_Process_queue+0x6c> <== NOT EXECUTED 1180bc: 52 push %edx <== NOT EXECUTED 1180bd: 52 push %edx <== NOT EXECUTED 1180be: ff 70 24 pushl 0x24(%eax) <== NOT EXECUTED 1180c1: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 1180c4: e8 0b c2 ff ff call 1142d4 <_Heap_Allocate> <== NOT EXECUTED 1180c9: 89 c2 mov %eax,%edx <== NOT EXECUTED the_segment = (void **) _Region_Allocate_segment( the_region, the_thread->Wait.count ); if ( the_segment == NULL ) 1180cb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1180ce: 85 c0 test %eax,%eax <== NOT EXECUTED 1180d0: 74 1a je 1180ec <_Region_Process_queue+0x6c> <== NOT EXECUTED break; *(void **)the_thread->Wait.return_argument = the_segment; 1180d2: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 1180d5: 89 10 mov %edx,(%eax) <== NOT EXECUTED the_region->number_of_used_blocks += 1; 1180d7: ff 46 64 incl 0x64(%esi) <== NOT EXECUTED _Thread_queue_Extract( &the_region->Wait_queue, the_thread ); 1180da: 50 push %eax <== NOT EXECUTED 1180db: 50 push %eax <== NOT EXECUTED 1180dc: 53 push %ebx <== NOT EXECUTED 1180dd: 57 push %edi <== NOT EXECUTED 1180de: e8 bd 05 00 00 call 1186a0 <_Thread_queue_Extract> <== NOT EXECUTED the_thread->Wait.return_code = RTEMS_SUCCESSFUL; 1180e3: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED 1180ea: eb bf jmp 1180ab <_Region_Process_queue+0x2b> <== NOT EXECUTED } _Thread_Enable_dispatch(); } 1180ec: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1180ef: 5b pop %ebx <== NOT EXECUTED 1180f0: 5e pop %esi <== NOT EXECUTED 1180f1: 5f pop %edi <== NOT EXECUTED 1180f2: c9 leave <== NOT EXECUTED *(void **)the_thread->Wait.return_argument = the_segment; the_region->number_of_used_blocks += 1; _Thread_queue_Extract( &the_region->Wait_queue, the_thread ); the_thread->Wait.return_code = RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 1180f3: e9 f4 d5 ff ff jmp 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 0010d37c <_Semaphore_Manager_initialization>: */ void _Semaphore_Manager_initialization( uint32_t maximum_semaphores ) { 10d37c: 55 push %ebp <== NOT EXECUTED 10d37d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d37f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d382: 6a 04 push $0x4 <== NOT EXECUTED 10d384: 6a 00 push $0x0 <== NOT EXECUTED 10d386: 6a 78 push $0x78 <== NOT EXECUTED 10d388: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d38b: 6a 03 push $0x3 <== NOT EXECUTED 10d38d: 6a 02 push $0x2 <== NOT EXECUTED 10d38f: 68 48 c9 11 00 push $0x11c948 <== NOT EXECUTED 10d394: e8 bf d2 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 10d399: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_SEMAPHORE, _Semaphore_MP_Process_packet ); #endif } 10d39c: c9 leave <== NOT EXECUTED 10d39d: c3 ret <== NOT EXECUTED 001092a0 <_Semaphore_Translate_core_mutex_return_code>: }; rtems_status_code _Semaphore_Translate_core_mutex_return_code ( uint32_t status ) { 1092a0: 55 push %ebp <== NOT EXECUTED 1092a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1092a3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1092a6: 8b 04 85 b8 67 11 00 mov 0x1167b8(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( status > CORE_MUTEX_STATUS_LAST ) return RTEMS_INTERNAL_ERROR; #endif return _Semaphore_Translate_core_mutex_return_code_[status]; } 1092ad: c9 leave <== NOT EXECUTED 1092ae: c3 ret <== NOT EXECUTED 001092af <_Semaphore_Translate_core_semaphore_return_code>: }; rtems_status_code _Semaphore_Translate_core_semaphore_return_code ( uint32_t status ) { 1092af: 55 push %ebp <== NOT EXECUTED 1092b0: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1092b2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1092b5: 8b 04 85 d4 67 11 00 mov 0x1167d4(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( status > CORE_SEMAPHORE_STATUS_LAST ) return RTEMS_INTERNAL_ERROR; #endif return _Semaphore_Translate_core_semaphore_return_code_[status]; } 1092bc: c9 leave <== NOT EXECUTED 1092bd: c3 ret <== NOT EXECUTED 0010d3a0 <_Signal_Manager_initialization>: * * Output parameters: NONE */ void _Signal_Manager_initialization( void ) { 10d3a0: 55 push %ebp <== NOT EXECUTED 10d3a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED _MPCI_Register_packet_processor( MP_PACKET_SIGNAL, _Signal_MP_Process_packet ); #endif } 10d3a3: c9 leave <== NOT EXECUTED 10d3a4: c3 ret <== NOT EXECUTED 00109e70 <_TOD_Get>: */ void _TOD_Get( struct timespec *time ) { 109e70: 55 push %ebp <== NOT EXECUTED 109e71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109e73: 56 push %esi <== NOT EXECUTED 109e74: 53 push %ebx <== NOT EXECUTED 109e75: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 109e78: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED ISR_Level level; struct timespec offset; /* assume time checked by caller */ offset.tv_sec = 0; 109e7b: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED offset.tv_nsec = 0; 109e82: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED /* _TOD_Now is a proper POSIX time */ _ISR_Disable( level ); 109e89: 9c pushf <== NOT EXECUTED 109e8a: fa cli <== NOT EXECUTED 109e8b: 5b pop %ebx <== NOT EXECUTED *time = _TOD_Now; 109e8c: a1 90 ca 11 00 mov 0x11ca90,%eax <== NOT EXECUTED 109e91: 8b 15 94 ca 11 00 mov 0x11ca94,%edx <== NOT EXECUTED 109e97: 89 06 mov %eax,(%esi) <== NOT EXECUTED 109e99: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED if ( _Watchdog_Nanoseconds_since_tick_handler ) 109e9c: a1 a4 cb 11 00 mov 0x11cba4,%eax <== NOT EXECUTED 109ea1: 85 c0 test %eax,%eax <== NOT EXECUTED 109ea3: 74 05 je 109eaa <_TOD_Get+0x3a> <== NOT EXECUTED offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)(); 109ea5: ff d0 call *%eax <== NOT EXECUTED 109ea7: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED _ISR_Enable( level ); 109eaa: 53 push %ebx <== NOT EXECUTED 109eab: 9d popf <== NOT EXECUTED _Timespec_Add_to( time, &offset ); 109eac: 50 push %eax <== NOT EXECUTED 109ead: 50 push %eax <== NOT EXECUTED 109eae: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 109eb1: 50 push %eax <== NOT EXECUTED 109eb2: 56 push %esi <== NOT EXECUTED 109eb3: e8 30 1a 00 00 call 10b8e8 <_Timespec_Add_to> <== NOT EXECUTED 109eb8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109ebb: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109ebe: 5b pop %ebx <== NOT EXECUTED 109ebf: 5e pop %esi <== NOT EXECUTED 109ec0: c9 leave <== NOT EXECUTED 109ec1: c3 ret <== NOT EXECUTED 0010d848 <_TOD_Get_uptime>: */ void _TOD_Get_uptime( struct timespec *uptime ) { 10d848: 55 push %ebp <== NOT EXECUTED 10d849: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d84b: 56 push %esi <== NOT EXECUTED 10d84c: 53 push %ebx <== NOT EXECUTED 10d84d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10d850: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED ISR_Level level; struct timespec offset; /* assume uptime checked by caller */ offset.tv_sec = 0; 10d853: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED offset.tv_nsec = 0; 10d85a: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED _ISR_Disable( level ); 10d861: 9c pushf <== NOT EXECUTED 10d862: fa cli <== NOT EXECUTED 10d863: 5b pop %ebx <== NOT EXECUTED *uptime = _TOD_Uptime; 10d864: a1 7c ca 11 00 mov 0x11ca7c,%eax <== NOT EXECUTED 10d869: 8b 15 80 ca 11 00 mov 0x11ca80,%edx <== NOT EXECUTED 10d86f: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10d871: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED if ( _Watchdog_Nanoseconds_since_tick_handler ) 10d874: a1 a4 cb 11 00 mov 0x11cba4,%eax <== NOT EXECUTED 10d879: 85 c0 test %eax,%eax <== NOT EXECUTED 10d87b: 74 05 je 10d882 <_TOD_Get_uptime+0x3a> <== NOT EXECUTED offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)(); 10d87d: ff d0 call *%eax <== NOT EXECUTED 10d87f: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED _ISR_Enable( level ); 10d882: 53 push %ebx <== NOT EXECUTED 10d883: 9d popf <== NOT EXECUTED _Timespec_Add_to( uptime, &offset ); 10d884: 50 push %eax <== NOT EXECUTED 10d885: 50 push %eax <== NOT EXECUTED 10d886: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10d889: 50 push %eax <== NOT EXECUTED 10d88a: 56 push %esi <== NOT EXECUTED 10d88b: e8 58 e0 ff ff call 10b8e8 <_Timespec_Add_to> <== NOT EXECUTED 10d890: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10d893: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d896: 5b pop %ebx <== NOT EXECUTED 10d897: 5e pop %esi <== NOT EXECUTED 10d898: c9 leave <== NOT EXECUTED 10d899: c3 ret <== NOT EXECUTED 00109ec4 <_TOD_Handler_initialization>: */ void _TOD_Handler_initialization( uint32_t microseconds_per_tick ) { 109ec4: 55 push %ebp <== NOT EXECUTED 109ec5: 89 e5 mov %esp,%ebp <== NOT EXECUTED _TOD_Microseconds_per_tick = microseconds_per_tick; 109ec7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109eca: a3 9c cb 11 00 mov %eax,0x11cb9c <== NOT EXECUTED /* POSIX format TOD (timespec) */ _TOD_Now.tv_sec = TOD_SECONDS_1970_THROUGH_1988; 109ecf: c7 05 90 ca 11 00 00 movl $0x21dae500,0x11ca90 <== NOT EXECUTED 109ed6: e5 da 21 <== NOT EXECUTED _TOD_Now.tv_nsec = 0; 109ed9: c7 05 94 ca 11 00 00 movl $0x0,0x11ca94 <== NOT EXECUTED 109ee0: 00 00 00 <== NOT EXECUTED /* Uptime (timespec) */ _TOD_Uptime.tv_sec = 0; 109ee3: c7 05 7c ca 11 00 00 movl $0x0,0x11ca7c <== NOT EXECUTED 109eea: 00 00 00 <== NOT EXECUTED _TOD_Uptime.tv_nsec = 0; 109eed: c7 05 80 ca 11 00 00 movl $0x0,0x11ca80 <== NOT EXECUTED 109ef4: 00 00 00 <== NOT EXECUTED /* TOD has not been set */ _TOD_Is_set = FALSE; 109ef7: c6 05 14 ca 11 00 00 movb $0x0,0x11ca14 <== NOT EXECUTED _TOD_Activate(); } 109efe: c9 leave <== NOT EXECUTED 109eff: c3 ret <== NOT EXECUTED 0010b0f4 <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 10b0f4: 55 push %ebp <== NOT EXECUTED 10b0f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b0f7: 53 push %ebx <== NOT EXECUTED 10b0f8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b0fb: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10b0fe: a1 bc 83 12 00 mov 0x1283bc,%eax <== NOT EXECUTED 10b103: 40 inc %eax <== NOT EXECUTED 10b104: a3 bc 83 12 00 mov %eax,0x1283bc <== NOT EXECUTED _Thread_Disable_dispatch(); _TOD_Deactivate(); if ( time->tv_sec < _TOD_Seconds_since_epoch ) 10b109: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10b10b: a1 4c 84 12 00 mov 0x12844c,%eax <== NOT EXECUTED 10b110: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10b112: 7d 08 jge 10b11c <_TOD_Set+0x28> <== NOT EXECUTED */ bool _Protected_heap_Free( Heap_Control *the_heap, void *start_address ); 10b114: 51 push %ecx <== NOT EXECUTED 10b115: 29 d0 sub %edx,%eax <== NOT EXECUTED 10b117: 50 push %eax <== NOT EXECUTED 10b118: 6a 01 push $0x1 <== NOT EXECUTED 10b11a: eb 06 jmp 10b122 <_TOD_Set+0x2e> <== NOT EXECUTED 10b11c: 51 push %ecx <== NOT EXECUTED 10b11d: 29 c2 sub %eax,%edx <== NOT EXECUTED 10b11f: 52 push %edx <== NOT EXECUTED 10b120: 6a 00 push $0x0 <== NOT EXECUTED 10b122: 68 90 84 12 00 push $0x128490 <== NOT EXECUTED 10b127: e8 68 20 00 00 call 10d194 <_Watchdog_Adjust> <== NOT EXECUTED 10b12c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 10b12f: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10b131: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10b134: a3 50 84 12 00 mov %eax,0x128450 <== NOT EXECUTED 10b139: 89 15 4c 84 12 00 mov %edx,0x12844c <== NOT EXECUTED _TOD_Is_set = TRUE; 10b13f: c6 05 d0 83 12 00 01 movb $0x1,0x1283d0 <== NOT EXECUTED _TOD_Activate(); _Thread_Enable_dispatch(); } 10b146: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b149: c9 leave <== NOT EXECUTED _TOD_Now = *time; _TOD_Is_set = TRUE; _TOD_Activate(); _Thread_Enable_dispatch(); 10b14a: e9 f1 0f 00 00 jmp 10c140 <_Thread_Enable_dispatch> <== NOT EXECUTED 00109f00 <_TOD_Tickle_ticks>: * * Output parameters: NONE */ void _TOD_Tickle_ticks( void ) { 109f00: 55 push %ebp <== NOT EXECUTED 109f01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109f03: 53 push %ebx <== NOT EXECUTED 109f04: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED struct timespec tick; uint32_t seconds; /* Convert the tick quantum to a timespec */ tick.tv_nsec = _TOD_Microseconds_per_tick * 1000; 109f07: 69 05 9c cb 11 00 e8 imul $0x3e8,0x11cb9c,%eax <== NOT EXECUTED 109f0e: 03 00 00 <== NOT EXECUTED 109f11: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED tick.tv_sec = 0; 109f14: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED /* Update the counter of ticks since boot */ _Watchdog_Ticks_since_boot += 1; 109f1b: a1 50 cb 11 00 mov 0x11cb50,%eax <== NOT EXECUTED 109f20: 40 inc %eax <== NOT EXECUTED 109f21: a3 50 cb 11 00 mov %eax,0x11cb50 <== NOT EXECUTED /* Update the timespec format uptime */ (void) _Timespec_Add_to( &_TOD_Uptime, &tick ); 109f26: 8d 5d f4 lea -0xc(%ebp),%ebx <== NOT EXECUTED 109f29: 53 push %ebx <== NOT EXECUTED 109f2a: 68 7c ca 11 00 push $0x11ca7c <== NOT EXECUTED 109f2f: e8 b4 19 00 00 call 10b8e8 <_Timespec_Add_to> <== NOT EXECUTED /* we do not care how much the uptime changed */ /* Update the timespec format TOD */ seconds = _Timespec_Add_to( &_TOD_Now, &tick ); 109f34: 58 pop %eax <== NOT EXECUTED 109f35: 5a pop %edx <== NOT EXECUTED 109f36: 53 push %ebx <== NOT EXECUTED 109f37: 68 90 ca 11 00 push $0x11ca90 <== NOT EXECUTED 109f3c: e8 a7 19 00 00 call 10b8e8 <_Timespec_Add_to> <== NOT EXECUTED 109f41: 89 c3 mov %eax,%ebx <== NOT EXECUTED 109f43: eb 0e jmp 109f53 <_TOD_Tickle_ticks+0x53> <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ); 109f45: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109f48: 68 d4 ca 11 00 push $0x11cad4 <== NOT EXECUTED 109f4d: e8 8a 1d 00 00 call 10bcdc <_Watchdog_Tickle> <== NOT EXECUTED while ( seconds ) { _Watchdog_Tickle_seconds(); seconds--; 109f52: 4b dec %ebx <== NOT EXECUTED 109f53: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (void) _Timespec_Add_to( &_TOD_Uptime, &tick ); /* we do not care how much the uptime changed */ /* Update the timespec format TOD */ seconds = _Timespec_Add_to( &_TOD_Now, &tick ); while ( seconds ) { 109f56: 85 db test %ebx,%ebx <== NOT EXECUTED 109f58: 75 eb jne 109f45 <_TOD_Tickle_ticks+0x45> <== NOT EXECUTED _Watchdog_Tickle_seconds(); seconds--; } } 109f5a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109f5d: c9 leave <== NOT EXECUTED 109f5e: c3 ret <== NOT EXECUTED 001099d0 <_TOD_To_seconds>: */ uint32_t _TOD_To_seconds( rtems_time_of_day *the_tod ) { 1099d0: 55 push %ebp <== NOT EXECUTED 1099d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099d3: 56 push %esi <== NOT EXECUTED 1099d4: 53 push %ebx <== NOT EXECUTED 1099d5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED uint32_t time; uint32_t year_mod_4; time = the_tod->day - 1; 1099d8: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 1099db: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED year_mod_4 = the_tod->year & 3; 1099de: 8b 13 mov (%ebx),%edx <== NOT EXECUTED if ( year_mod_4 == 0 ) 1099e0: 89 d6 mov %edx,%esi <== NOT EXECUTED 1099e2: 83 e6 03 and $0x3,%esi <== NOT EXECUTED 1099e5: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 1099e8: 75 0a jne 1099f4 <_TOD_To_seconds+0x24> <== NOT EXECUTED time += _TOD_Days_to_date[ 1 ][ the_tod->month ]; 1099ea: 0f b7 84 00 5a 98 11 movzwl 0x11985a(%eax,%eax,1),%eax <== NOT EXECUTED 1099f1: 00 <== NOT EXECUTED 1099f2: eb 08 jmp 1099fc <_TOD_To_seconds+0x2c> <== NOT EXECUTED else time += _TOD_Days_to_date[ 0 ][ the_tod->month ]; 1099f4: 0f b7 84 00 40 98 11 movzwl 0x119840(%eax,%eax,1),%eax <== NOT EXECUTED 1099fb: 00 <== NOT EXECUTED 1099fc: 8d 0c 08 lea (%eax,%ecx,1),%ecx <== NOT EXECUTED time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) * 1099ff: 0f b7 84 36 74 98 11 movzwl 0x119874(%esi,%esi,1),%eax <== NOT EXECUTED 109a06: 00 <== NOT EXECUTED 109a07: 81 ea c4 07 00 00 sub $0x7c4,%edx <== NOT EXECUTED 109a0d: c1 ea 02 shr $0x2,%edx <== NOT EXECUTED 109a10: 69 d2 b5 05 00 00 imul $0x5b5,%edx,%edx <== NOT EXECUTED 109a16: 01 d0 add %edx,%eax <== NOT EXECUTED ( (TOD_DAYS_PER_YEAR * 4) + 1); time += _TOD_Days_since_last_leap_year[ year_mod_4 ]; 109a18: 01 c8 add %ecx,%eax <== NOT EXECUTED time *= TOD_SECONDS_PER_DAY; 109a1a: 69 c0 80 51 01 00 imul $0x15180,%eax,%eax <== NOT EXECUTED time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute) * TOD_SECONDS_PER_MINUTE; time += the_tod->second; 109a20: 6b 53 0c 3c imul $0x3c,0xc(%ebx),%edx <== NOT EXECUTED 109a24: 03 53 10 add 0x10(%ebx),%edx <== NOT EXECUTED 109a27: 6b d2 3c imul $0x3c,%edx,%edx <== NOT EXECUTED 109a2a: 03 43 14 add 0x14(%ebx),%eax <== NOT EXECUTED 109a2d: 8d 84 10 00 e5 da 21 lea 0x21dae500(%eax,%edx,1),%eax <== NOT EXECUTED time += TOD_SECONDS_1970_THROUGH_1988; return( time ); } 109a34: 5b pop %ebx <== NOT EXECUTED 109a35: 5e pop %esi <== NOT EXECUTED 109a36: c9 leave <== NOT EXECUTED 109a37: c3 ret <== NOT EXECUTED 00109a38 <_TOD_Validate>: */ bool _TOD_Validate( rtems_time_of_day *the_tod ) { 109a38: 55 push %ebp <== NOT EXECUTED 109a39: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a3b: 53 push %ebx <== NOT EXECUTED 109a3c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 109a3f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED uint32_t days_in_month; if ((!the_tod) || 109a42: 85 db test %ebx,%ebx <== NOT EXECUTED 109a44: 74 5d je 109aa3 <_TOD_Validate+0x6b> <== NOT EXECUTED 109a46: b8 40 42 0f 00 mov $0xf4240,%eax <== NOT EXECUTED 109a4b: 31 d2 xor %edx,%edx <== NOT EXECUTED 109a4d: f7 35 58 85 12 00 divl 0x128558 <== NOT EXECUTED 109a53: 39 43 18 cmp %eax,0x18(%ebx) <== NOT EXECUTED 109a56: 73 4b jae 109aa3 <_TOD_Validate+0x6b> <== NOT EXECUTED 109a58: 83 7b 14 3b cmpl $0x3b,0x14(%ebx) <== NOT EXECUTED 109a5c: 77 45 ja 109aa3 <_TOD_Validate+0x6b> <== NOT EXECUTED 109a5e: 83 7b 10 3b cmpl $0x3b,0x10(%ebx) <== NOT EXECUTED 109a62: 77 3f ja 109aa3 <_TOD_Validate+0x6b> <== NOT EXECUTED 109a64: 83 7b 0c 17 cmpl $0x17,0xc(%ebx) <== NOT EXECUTED 109a68: 77 39 ja 109aa3 <_TOD_Validate+0x6b> <== NOT EXECUTED 109a6a: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 109a6d: 85 c0 test %eax,%eax <== NOT EXECUTED 109a6f: 74 32 je 109aa3 <_TOD_Validate+0x6b> <== NOT EXECUTED 109a71: 83 f8 0c cmp $0xc,%eax <== NOT EXECUTED 109a74: 77 2d ja 109aa3 <_TOD_Validate+0x6b> <== NOT EXECUTED 109a76: 8b 0b mov (%ebx),%ecx <== NOT EXECUTED 109a78: 81 f9 c3 07 00 00 cmp $0x7c3,%ecx <== NOT EXECUTED 109a7e: 76 23 jbe 109aa3 <_TOD_Validate+0x6b> <== NOT EXECUTED 109a80: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 109a83: 85 d2 test %edx,%edx <== NOT EXECUTED 109a85: 74 1c je 109aa3 <_TOD_Validate+0x6b> <== NOT EXECUTED (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 109a87: 80 e1 03 and $0x3,%cl <== NOT EXECUTED 109a8a: 75 09 jne 109a95 <_TOD_Validate+0x5d> <== NOT EXECUTED days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 109a8c: 8b 04 85 b0 98 11 00 mov 0x1198b0(,%eax,4),%eax <== NOT EXECUTED 109a93: eb 07 jmp 109a9c <_TOD_Validate+0x64> <== NOT EXECUTED else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 109a95: 8b 04 85 7c 98 11 00 mov 0x11987c(,%eax,4),%eax <== NOT EXECUTED 109a9c: 39 c2 cmp %eax,%edx <== NOT EXECUTED 109a9e: 0f 96 c0 setbe %al <== NOT EXECUTED 109aa1: eb 02 jmp 109aa5 <_TOD_Validate+0x6d> <== NOT EXECUTED 109aa3: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( the_tod->day > days_in_month ) return false; return true; } 109aa5: 5a pop %edx <== NOT EXECUTED 109aa6: 5b pop %ebx <== NOT EXECUTED 109aa7: c9 leave <== NOT EXECUTED 109aa8: c3 ret <== NOT EXECUTED 0010a920 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10a920: 55 push %ebp <== NOT EXECUTED 10a921: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a923: 57 push %edi <== NOT EXECUTED 10a924: 56 push %esi <== NOT EXECUTED 10a925: 53 push %ebx <== NOT EXECUTED 10a926: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10a929: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a92c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10a92f: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 10a932: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED */ /* * Save original state */ original_state = the_thread->current_state; 10a935: 8b 7b 10 mov 0x10(%ebx),%edi <== NOT EXECUTED /* * 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 ); 10a938: 53 push %ebx <== NOT EXECUTED 10a939: e8 3e 0d 00 00 call 10b67c <_Thread_Set_transient> <== NOT EXECUTED /* * Do not bother recomputing all the priority related information if * we are not REALLY changing priority. */ if ( the_thread->current_priority != new_priority ) 10a93e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a941: 39 73 14 cmp %esi,0x14(%ebx) <== NOT EXECUTED 10a944: 74 0c je 10a952 <_Thread_Change_priority+0x32> <== NOT EXECUTED _Thread_Set_priority( the_thread, new_priority ); 10a946: 50 push %eax <== NOT EXECUTED 10a947: 50 push %eax <== NOT EXECUTED 10a948: 56 push %esi <== NOT EXECUTED 10a949: 53 push %ebx <== NOT EXECUTED 10a94a: e8 f9 0b 00 00 call 10b548 <_Thread_Set_priority> <== NOT EXECUTED 10a94f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _ISR_Disable( level ); 10a952: 9c pushf <== NOT EXECUTED 10a953: fa cli <== NOT EXECUTED 10a954: 5e pop %esi <== NOT EXECUTED /* * 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; 10a955: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED if ( state != STATES_TRANSIENT ) { 10a958: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10a95b: 74 30 je 10a98d <_Thread_Change_priority+0x6d> <== NOT EXECUTED /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10a95d: 83 e7 04 and $0x4,%edi <== NOT EXECUTED 10a960: 75 08 jne 10a96a <_Thread_Change_priority+0x4a> <== NOT EXECUTED the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10a962: 89 d0 mov %edx,%eax <== NOT EXECUTED 10a964: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 10a967: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10a96a: 56 push %esi <== NOT EXECUTED 10a96b: 9d popf <== NOT EXECUTED if ( _States_Is_waiting_on_thread_queue( state ) ) { 10a96c: 81 e2 e0 be 03 00 and $0x3bee0,%edx <== NOT EXECUTED 10a972: 0f 84 c0 00 00 00 je 10aa38 <_Thread_Change_priority+0x118> <== NOT EXECUTED _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10a978: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 10a97b: 8b 43 44 mov 0x44(%ebx),%eax <== NOT EXECUTED 10a97e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10a981: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a984: 5b pop %ebx <== NOT EXECUTED 10a985: 5e pop %esi <== NOT EXECUTED 10a986: 5f pop %edi <== NOT EXECUTED 10a987: c9 leave <== NOT EXECUTED /* 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 ); 10a988: e9 33 0b 00 00 jmp 10b4c0 <_Thread_queue_Requeue> <== NOT EXECUTED } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10a98d: 83 e7 04 and $0x4,%edi <== NOT EXECUTED 10a990: 75 53 jne 10a9e5 <_Thread_Change_priority+0xc5> <== NOT EXECUTED * 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 ); 10a992: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in 10a999: 8b 93 90 00 00 00 mov 0x90(%ebx),%edx <== NOT EXECUTED 10a99f: 66 8b 83 96 00 00 00 mov 0x96(%ebx),%ax <== NOT EXECUTED 10a9a6: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10a9a9: 66 a1 b4 ca 11 00 mov 0x11cab4,%ax <== NOT EXECUTED 10a9af: 0b 83 94 00 00 00 or 0x94(%ebx),%eax <== NOT EXECUTED 10a9b5: 66 a3 b4 ca 11 00 mov %ax,0x11cab4 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); if ( prepend_it ) 10a9bb: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10a9bf: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx <== NOT EXECUTED 10a9c5: 74 0e je 10a9d5 <_Thread_Change_priority+0xb5> <== NOT EXECUTED 10a9c7: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED 10a9ca: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10a9cc: 89 1a mov %ebx,(%edx) <== NOT EXECUTED 10a9ce: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10a9d0: 89 58 04 mov %ebx,0x4(%eax) <== NOT EXECUTED 10a9d3: eb 10 jmp 10a9e5 <_Thread_Change_priority+0xc5> <== NOT EXECUTED 10a9d5: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10a9d8: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10a9da: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10a9dd: 89 5a 08 mov %ebx,0x8(%edx) <== NOT EXECUTED 10a9e0: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10a9e2: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED _Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node ); else _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node ); } _ISR_Flash( level ); 10a9e5: 56 push %esi <== NOT EXECUTED 10a9e6: 9d popf <== NOT EXECUTED 10a9e7: fa cli <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10a9e8: 66 8b 0d b4 ca 11 00 mov 0x11cab4,%cx <== NOT EXECUTED 10a9ef: 31 d2 xor %edx,%edx <== NOT EXECUTED 10a9f1: 89 d0 mov %edx,%eax <== NOT EXECUTED 10a9f3: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10a9f7: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10a9fa: 66 8b 8c 00 2c cb 11 mov 0x11cb2c(%eax,%eax,1),%cx <== NOT EXECUTED 10aa01: 00 <== NOT EXECUTED 10aa02: 66 0f bc d1 bsf %cx,%dx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10aa06: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10aa09: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10aa0c: 01 d0 add %edx,%eax <== NOT EXECUTED 10aa0e: 6b c0 0c imul $0xc,%eax,%eax <== NOT EXECUTED 10aa11: 8b 15 c8 c9 11 00 mov 0x11c9c8,%edx <== NOT EXECUTED 10aa17: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10aa1a: a3 8c ca 11 00 mov %eax,0x11ca8c <== NOT EXECUTED void *starting_address, size_t size ); /** * This function attempts to allocate a block of @a size bytes from 10aa1f: 8b 15 c0 ca 11 00 mov 0x11cac0,%edx <== NOT EXECUTED * We altered the set of thread priorities. So let's figure out * who is the heir and if we need to switch to them. */ _Thread_Calculate_heir(); if ( !_Thread_Is_executing_also_the_heir() && 10aa25: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10aa27: 74 0d je 10aa36 <_Thread_Change_priority+0x116> <== NOT EXECUTED 10aa29: 80 7a 76 00 cmpb $0x0,0x76(%edx) <== NOT EXECUTED 10aa2d: 74 07 je 10aa36 <_Thread_Change_priority+0x116> <== NOT EXECUTED _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; 10aa2f: c6 05 d0 ca 11 00 01 movb $0x1,0x11cad0 <== NOT EXECUTED _ISR_Enable( level ); 10aa36: 56 push %esi <== NOT EXECUTED 10aa37: 9d popf <== NOT EXECUTED } 10aa38: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aa3b: 5b pop %ebx <== NOT EXECUTED 10aa3c: 5e pop %esi <== NOT EXECUTED 10aa3d: 5f pop %edi <== NOT EXECUTED 10aa3e: c9 leave <== NOT EXECUTED 10aa3f: c3 ret <== NOT EXECUTED 0010aa40 <_Thread_Clear_state>: void _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) { 10aa40: 55 push %ebp <== NOT EXECUTED 10aa41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa43: 53 push %ebx <== NOT EXECUTED 10aa44: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10aa47: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10aa4a: 9c pushf <== NOT EXECUTED 10aa4b: fa cli <== NOT EXECUTED 10aa4c: 5b pop %ebx <== NOT EXECUTED current_state = the_thread->current_state; 10aa4d: 8b 51 10 mov 0x10(%ecx),%edx <== NOT EXECUTED if ( current_state & state ) { 10aa50: 85 d0 test %edx,%eax <== NOT EXECUTED 10aa52: 74 6f je 10aac3 <_Thread_Clear_state+0x83> <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 10aa54: f7 d0 not %eax <== NOT EXECUTED 10aa56: 21 d0 and %edx,%eax <== NOT EXECUTED current_state = 10aa58: 89 41 10 mov %eax,0x10(%ecx) <== NOT EXECUTED the_thread->current_state = _States_Clear( state, current_state ); if ( _States_Is_ready( current_state ) ) { 10aa5b: 85 c0 test %eax,%eax <== NOT EXECUTED 10aa5d: 75 64 jne 10aac3 <_Thread_Clear_state+0x83> <== NOT EXECUTED * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in 10aa5f: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10aa65: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10aa6c: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10aa6f: 66 a1 b4 ca 11 00 mov 0x11cab4,%ax <== NOT EXECUTED 10aa75: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10aa7b: 66 a3 b4 ca 11 00 mov %ax,0x11cab4 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10aa81: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10aa87: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10aa8a: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10aa8c: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10aa8f: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10aa92: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10aa94: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10aa97: 53 push %ebx <== NOT EXECUTED 10aa98: 9d popf <== NOT EXECUTED 10aa99: fa cli <== NOT EXECUTED * 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 ( the_thread->current_priority < _Thread_Heir->current_priority ) { 10aa9a: 8b 51 14 mov 0x14(%ecx),%edx <== NOT EXECUTED 10aa9d: a1 8c ca 11 00 mov 0x11ca8c,%eax <== NOT EXECUTED 10aaa2: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10aaa5: 73 1c jae 10aac3 <_Thread_Clear_state+0x83> <== NOT EXECUTED _Thread_Heir = the_thread; 10aaa7: 89 0d 8c ca 11 00 mov %ecx,0x11ca8c <== NOT EXECUTED if ( _Thread_Executing->is_preemptible || 10aaad: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 10aab2: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10aab6: 75 04 jne 10aabc <_Thread_Clear_state+0x7c> <== NOT EXECUTED 10aab8: 85 d2 test %edx,%edx <== NOT EXECUTED 10aaba: 75 07 jne 10aac3 <_Thread_Clear_state+0x83> <== NOT EXECUTED the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 10aabc: c6 05 d0 ca 11 00 01 movb $0x1,0x11cad0 <== NOT EXECUTED } } } _ISR_Enable( level ); 10aac3: 53 push %ebx <== NOT EXECUTED 10aac4: 9d popf <== NOT EXECUTED } 10aac5: 5b pop %ebx <== NOT EXECUTED 10aac6: c9 leave <== NOT EXECUTED 10aac7: c3 ret <== NOT EXECUTED 0010aac8 <_Thread_Close>: void _Thread_Close( Objects_Information *information, Thread_Control *the_thread ) { 10aac8: 55 push %ebp <== NOT EXECUTED 10aac9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aacb: 56 push %esi <== NOT EXECUTED 10aacc: 53 push %ebx <== NOT EXECUTED 10aacd: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10aad0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10aad3: 0f b7 56 08 movzwl 0x8(%esi),%edx <== NOT EXECUTED 10aad7: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10aada: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) <== NOT EXECUTED 10aae1: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10aae6: 48 dec %eax <== NOT EXECUTED 10aae7: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED * disappear and set a transient state on it. So we temporarily * unnest dispatching. */ _Thread_Unnest_dispatch(); _User_extensions_Thread_delete( the_thread ); 10aaec: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aaef: 56 push %esi <== NOT EXECUTED 10aaf0: e8 c3 0f 00 00 call 10bab8 <_User_extensions_Thread_delete> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10aaf5: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10aafa: 40 inc %eax <== NOT EXECUTED 10aafb: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED /* * Now we are in a dispatching critical section again and we * can take the thread OUT of the published set. It is invalid * to use this thread's Id OR name after this call. */ _Objects_Close( information, &the_thread->Object ); 10ab00: 59 pop %ecx <== NOT EXECUTED 10ab01: 58 pop %eax <== NOT EXECUTED 10ab02: 56 push %esi <== NOT EXECUTED 10ab03: 53 push %ebx <== NOT EXECUTED 10ab04: e8 27 f7 ff ff call 10a230 <_Objects_Close> <== NOT EXECUTED /* * By setting the dormant state, the thread will not be considered * for scheduling when we remove any blocking states. */ _Thread_Set_state( the_thread, STATES_DORMANT ); 10ab09: 58 pop %eax <== NOT EXECUTED 10ab0a: 5a pop %edx <== NOT EXECUTED 10ab0b: 6a 01 push $0x1 <== NOT EXECUTED 10ab0d: 56 push %esi <== NOT EXECUTED 10ab0e: e8 9d 0a 00 00 call 10b5b0 <_Thread_Set_state> <== NOT EXECUTED if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 10ab13: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10ab16: e8 d9 08 00 00 call 10b3f4 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 10ab1b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ab1e: 84 c0 test %al,%al <== NOT EXECUTED 10ab20: 75 15 jne 10ab37 <_Thread_Close+0x6f> <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 10ab22: 83 7e 50 02 cmpl $0x2,0x50(%esi) <== NOT EXECUTED 10ab26: 75 0f jne 10ab37 <_Thread_Close+0x6f> <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10ab28: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab2b: 8d 46 48 lea 0x48(%esi),%eax <== NOT EXECUTED 10ab2e: 50 push %eax <== NOT EXECUTED 10ab2f: e8 40 11 00 00 call 10bc74 <_Watchdog_Remove> <== NOT EXECUTED 10ab34: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * The thread might have been FP. So deal with that. */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( _Thread_Is_allocated_fp( the_thread ) ) 10ab37: 3b 35 84 ca 11 00 cmp 0x11ca84,%esi <== NOT EXECUTED 10ab3d: 75 0a jne 10ab49 <_Thread_Close+0x81> <== NOT EXECUTED * @param[in] size is the new size * * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. */ bool _Protected_heap_Resize_block( 10ab3f: c7 05 84 ca 11 00 00 movl $0x0,0x11ca84 <== NOT EXECUTED 10ab46: 00 00 00 <== NOT EXECUTED _Thread_Deallocate_fp(); #endif the_thread->fp_context = NULL; 10ab49: c7 86 ec 00 00 00 00 movl $0x0,0xec(%esi) <== NOT EXECUTED 10ab50: 00 00 00 <== NOT EXECUTED if ( the_thread->Start.fp_context ) 10ab53: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED 10ab59: 85 c0 test %eax,%eax <== NOT EXECUTED 10ab5b: 74 0c je 10ab69 <_Thread_Close+0xa1> <== NOT EXECUTED (void) _Workspace_Free( the_thread->Start.fp_context ); 10ab5d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab60: 50 push %eax <== NOT EXECUTED 10ab61: e8 e2 11 00 00 call 10bd48 <_Workspace_Free> <== NOT EXECUTED 10ab66: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Free the rest of the memory associated with this task * and set the associated pointers to NULL for safety. */ _Thread_Stack_Free( the_thread ); 10ab69: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab6c: 56 push %esi <== NOT EXECUTED 10ab6d: e8 ca 0b 00 00 call 10b73c <_Thread_Stack_Free> <== NOT EXECUTED the_thread->Start.stack = NULL; 10ab72: c7 86 d0 00 00 00 00 movl $0x0,0xd0(%esi) <== NOT EXECUTED 10ab79: 00 00 00 <== NOT EXECUTED if ( the_thread->extensions ) 10ab7c: 8b 86 00 01 00 00 mov 0x100(%esi),%eax <== NOT EXECUTED 10ab82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ab85: 85 c0 test %eax,%eax <== NOT EXECUTED 10ab87: 74 0c je 10ab95 <_Thread_Close+0xcd> <== NOT EXECUTED (void) _Workspace_Free( the_thread->extensions ); 10ab89: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab8c: 50 push %eax <== NOT EXECUTED 10ab8d: e8 b6 11 00 00 call 10bd48 <_Workspace_Free> <== NOT EXECUTED 10ab92: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_thread->extensions = NULL; 10ab95: c7 86 00 01 00 00 00 movl $0x0,0x100(%esi) <== NOT EXECUTED 10ab9c: 00 00 00 <== NOT EXECUTED } 10ab9f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10aba2: 5b pop %ebx <== NOT EXECUTED 10aba3: 5e pop %esi <== NOT EXECUTED 10aba4: c9 leave <== NOT EXECUTED 10aba5: c3 ret <== NOT EXECUTED 0010aba8 <_Thread_Create_idle>: * * _Thread_Create_idle */ void _Thread_Create_idle( void ) { 10aba8: 55 push %ebp <== NOT EXECUTED 10aba9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10abab: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10abae: 68 5c cb 11 00 push $0x11cb5c <== NOT EXECUTED 10abb3: e8 04 f6 ff ff call 10a1bc <_Objects_Allocate> <== NOT EXECUTED /* * The entire workspace is zeroed during its initialization. Thus, all * fields not explicitly assigned were explicitly zeroed by * _Workspace_Initialization. */ _Thread_Idle = _Thread_Internal_allocate(); 10abb8: a3 a8 cb 11 00 mov %eax,0x11cba8 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10abbd: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10abc2: 40 inc %eax <== NOT EXECUTED 10abc3: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED * that when _Thread_Initialize unnests dispatch that we do not * do anything stupid. */ _Thread_Disable_dispatch(); _Thread_Initialize( 10abc8: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 10abcd: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED 10abd0: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10abd3: 68 58 68 11 00 push $0x116858 <== NOT EXECUTED 10abd8: 6a 00 push $0x0 <== NOT EXECUTED 10abda: 6a 00 push $0x0 <== NOT EXECUTED 10abdc: 6a 00 push $0x0 <== NOT EXECUTED 10abde: 6a 01 push $0x1 <== NOT EXECUTED 10abe0: 0f b6 05 84 86 11 00 movzbl 0x118684,%eax <== NOT EXECUTED 10abe7: 50 push %eax <== NOT EXECUTED 10abe8: 6a 00 push $0x0 <== NOT EXECUTED 10abea: a1 80 86 11 00 mov 0x118680,%eax <== NOT EXECUTED 10abef: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10abf1: 73 02 jae 10abf5 <_Thread_Create_idle+0x4d> <== NOT EXECUTED 10abf3: 89 d0 mov %edx,%eax <== NOT EXECUTED 10abf5: 50 push %eax <== NOT EXECUTED 10abf6: 6a 00 push $0x0 <== NOT EXECUTED 10abf8: ff 35 a8 cb 11 00 pushl 0x11cba8 <== NOT EXECUTED 10abfe: 68 5c cb 11 00 push $0x11cb5c <== NOT EXECUTED 10ac03: e8 50 02 00 00 call 10ae58 <_Thread_Initialize> <== NOT EXECUTED 10ac08: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10ac0d: 48 dec %eax <== NOT EXECUTED 10ac0e: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 10ac13: 8b 15 a8 cb 11 00 mov 0x11cba8,%edx <== NOT EXECUTED 10ac19: 89 15 c0 ca 11 00 mov %edx,0x11cac0 <== NOT EXECUTED 10ac1f: 89 15 8c ca 11 00 mov %edx,0x11ca8c <== NOT EXECUTED _Thread_Executing = _Thread_Idle; _Thread_Start( 10ac25: 83 c4 24 add $0x24,%esp <== NOT EXECUTED 10ac28: 6a 00 push $0x0 <== NOT EXECUTED 10ac2a: 6a 00 push $0x0 <== NOT EXECUTED 10ac2c: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 10ac31: ff 70 14 pushl 0x14(%eax) <== NOT EXECUTED 10ac34: 6a 00 push $0x0 <== NOT EXECUTED 10ac36: 52 push %edx <== NOT EXECUTED 10ac37: e8 8c 0b 00 00 call 10b7c8 <_Thread_Start> <== NOT EXECUTED 10ac3c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED _Configuration_Table->idle_task, NULL, 0 ); } 10ac3f: c9 leave <== NOT EXECUTED 10ac40: c3 ret <== NOT EXECUTED 0010ac44 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 10ac44: 55 push %ebp <== NOT EXECUTED 10ac45: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac47: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10ac4a: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10ac4d: 50 push %eax <== NOT EXECUTED 10ac4e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ac51: e8 8a 01 00 00 call 10ade0 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10ac56: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac59: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 10ac5d: 75 1b jne 10ac7a <_Thread_Delay_ended+0x36> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10ac5f: 52 push %edx <== NOT EXECUTED 10ac60: 52 push %edx <== NOT EXECUTED 10ac61: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10ac66: 50 push %eax <== NOT EXECUTED 10ac67: e8 d4 fd ff ff call 10aa40 <_Thread_Clear_state> <== NOT EXECUTED 10ac6c: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10ac71: 48 dec %eax <== NOT EXECUTED 10ac72: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED 10ac77: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_LOCAL: _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; } } 10ac7a: c9 leave <== NOT EXECUTED 10ac7b: c3 ret <== NOT EXECUTED 0010ac7c <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10ac7c: 55 push %ebp <== NOT EXECUTED 10ac7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac7f: 57 push %edi <== NOT EXECUTED 10ac80: 56 push %esi <== NOT EXECUTED 10ac81: 53 push %ebx <== NOT EXECUTED 10ac82: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10ac85: 8b 1d c0 ca 11 00 mov 0x11cac0,%ebx <== NOT EXECUTED _ISR_Disable( level ); 10ac8b: 9c pushf <== NOT EXECUTED 10ac8c: fa cli <== NOT EXECUTED 10ac8d: 5a pop %edx <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec uptime, ran; _TOD_Get_uptime( &uptime ); _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); 10ac8e: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 10ac91: e9 f1 00 00 00 jmp 10ad87 <_Thread_Dispatch+0x10b> <== NOT EXECUTED ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Context_Switch_necessary == TRUE ) { heir = _Thread_Heir; 10ac96: 8b 35 8c ca 11 00 mov 0x11ca8c,%esi <== NOT EXECUTED _Thread_Dispatch_disable_level = 1; 10ac9c: c7 05 00 ca 11 00 01 movl $0x1,0x11ca00 <== NOT EXECUTED 10aca3: 00 00 00 <== NOT EXECUTED _Context_Switch_necessary = FALSE; 10aca6: c6 05 d0 ca 11 00 00 movb $0x0,0x11cad0 <== NOT EXECUTED _Thread_Executing = heir; 10acad: 89 35 c0 ca 11 00 mov %esi,0x11cac0 <== NOT EXECUTED #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 ) 10acb3: 83 7e 7c 01 cmpl $0x1,0x7c(%esi) <== NOT EXECUTED 10acb7: 75 08 jne 10acc1 <_Thread_Dispatch+0x45> <== NOT EXECUTED heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10acb9: a1 cc c9 11 00 mov 0x11c9cc,%eax <== NOT EXECUTED 10acbe: 89 46 78 mov %eax,0x78(%esi) <== NOT EXECUTED _ISR_Enable( level ); 10acc1: 52 push %edx <== NOT EXECUTED 10acc2: 9d popf <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec uptime, ran; _TOD_Get_uptime( &uptime ); 10acc3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10acc6: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10acc9: 50 push %eax <== NOT EXECUTED 10acca: e8 79 2b 00 00 call 10d848 <_TOD_Get_uptime> <== NOT EXECUTED _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); 10accf: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10acd2: 57 push %edi <== NOT EXECUTED 10acd3: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10acd6: 50 push %eax <== NOT EXECUTED 10acd7: 68 c8 ca 11 00 push $0x11cac8 <== NOT EXECUTED 10acdc: e8 37 0c 00 00 call 10b918 <_Timespec_Subtract> <== NOT EXECUTED _Timespec_Add_to( &executing->cpu_time_used, &ran ); 10ace1: 58 pop %eax <== NOT EXECUTED 10ace2: 5a pop %edx <== NOT EXECUTED 10ace3: 57 push %edi <== NOT EXECUTED 10ace4: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax <== NOT EXECUTED 10acea: 50 push %eax <== NOT EXECUTED 10aceb: e8 f8 0b 00 00 call 10b8e8 <_Timespec_Add_to> <== NOT EXECUTED _Thread_Time_of_last_context_switch = uptime; 10acf0: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10acf3: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10acf6: a3 c8 ca 11 00 mov %eax,0x11cac8 <== NOT EXECUTED 10acfb: 89 15 cc ca 11 00 mov %edx,0x11cacc <== NOT EXECUTED #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10ad01: 8b 15 88 ca 11 00 mov 0x11ca88,%edx <== NOT EXECUTED 10ad07: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad0a: 85 d2 test %edx,%edx <== NOT EXECUTED 10ad0c: 74 10 je 10ad1e <_Thread_Dispatch+0xa2> <== NOT EXECUTED executing->libc_reent = *_Thread_libc_reent; 10ad0e: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10ad10: 89 83 f0 00 00 00 mov %eax,0xf0(%ebx) <== NOT EXECUTED *_Thread_libc_reent = heir->libc_reent; 10ad16: 8b 86 f0 00 00 00 mov 0xf0(%esi),%eax <== NOT EXECUTED 10ad1c: 89 02 mov %eax,(%edx) <== NOT EXECUTED } _User_extensions_Thread_switch( executing, heir ); 10ad1e: 51 push %ecx <== NOT EXECUTED 10ad1f: 51 push %ecx <== NOT EXECUTED 10ad20: 56 push %esi <== NOT EXECUTED 10ad21: 53 push %ebx <== NOT EXECUTED 10ad22: e8 01 0e 00 00 call 10bb28 <_User_extensions_Thread_switch> <== NOT EXECUTED if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10ad27: 58 pop %eax <== NOT EXECUTED 10ad28: 5a pop %edx <== NOT EXECUTED 10ad29: 8d 86 d4 00 00 00 lea 0xd4(%esi),%eax <== NOT EXECUTED 10ad2f: 50 push %eax <== NOT EXECUTED 10ad30: 8d 83 d4 00 00 00 lea 0xd4(%ebx),%eax <== NOT EXECUTED 10ad36: 50 push %eax <== NOT EXECUTED 10ad37: e8 b4 10 00 00 call 10bdf0 <_CPU_Context_switch> <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10ad3c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad3f: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx) <== NOT EXECUTED 10ad46: 74 36 je 10ad7e <_Thread_Dispatch+0x102> <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10ad48: a1 84 ca 11 00 mov 0x11ca84,%eax <== NOT EXECUTED 10ad4d: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10ad4f: 74 2d je 10ad7e <_Thread_Dispatch+0x102> <== NOT EXECUTED !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10ad51: 85 c0 test %eax,%eax <== NOT EXECUTED 10ad53: 74 11 je 10ad66 <_Thread_Dispatch+0xea> <== NOT EXECUTED _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10ad55: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad58: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10ad5d: 50 push %eax <== NOT EXECUTED 10ad5e: e8 c1 10 00 00 call 10be24 <_CPU_Context_save_fp> <== NOT EXECUTED 10ad63: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Context_Restore_fp( &executing->fp_context ); 10ad66: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad69: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax <== NOT EXECUTED 10ad6f: 50 push %eax <== NOT EXECUTED 10ad70: e8 b9 10 00 00 call 10be2e <_CPU_Context_restore_fp> <== NOT EXECUTED _Thread_Allocated_fp = executing; 10ad75: 89 1d 84 ca 11 00 mov %ebx,0x11ca84 <== NOT EXECUTED 10ad7b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10ad7e: 8b 1d c0 ca 11 00 mov 0x11cac0,%ebx <== NOT EXECUTED _ISR_Disable( level ); 10ad84: 9c pushf <== NOT EXECUTED 10ad85: fa cli <== NOT EXECUTED 10ad86: 5a pop %edx <== NOT EXECUTED Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Context_Switch_necessary == TRUE ) { 10ad87: a0 d0 ca 11 00 mov 0x11cad0,%al <== NOT EXECUTED 10ad8c: 84 c0 test %al,%al <== NOT EXECUTED 10ad8e: 0f 85 02 ff ff ff jne 10ac96 <_Thread_Dispatch+0x1a> <== NOT EXECUTED executing = _Thread_Executing; _ISR_Disable( level ); } _Thread_Dispatch_disable_level = 0; 10ad94: c7 05 00 ca 11 00 00 movl $0x0,0x11ca00 <== NOT EXECUTED 10ad9b: 00 00 00 <== NOT EXECUTED _ISR_Enable( level ); 10ad9e: 52 push %edx <== NOT EXECUTED 10ad9f: 9d popf <== NOT EXECUTED if ( _Thread_Do_post_task_switch_extension || 10ada0: 83 3d a4 ca 11 00 00 cmpl $0x0,0x11caa4 <== NOT EXECUTED 10ada7: 75 06 jne 10adaf <_Thread_Dispatch+0x133> <== NOT EXECUTED 10ada9: 80 7b 75 00 cmpb $0x0,0x75(%ebx) <== NOT EXECUTED 10adad: 74 09 je 10adb8 <_Thread_Dispatch+0x13c> <== NOT EXECUTED executing->do_post_task_switch_extension ) { executing->do_post_task_switch_extension = false; 10adaf: c6 43 75 00 movb $0x0,0x75(%ebx) <== NOT EXECUTED _API_extensions_Run_postswitch(); 10adb3: e8 4b eb ff ff call 109903 <_API_extensions_Run_postswitch> <== NOT EXECUTED } } 10adb8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10adbb: 5b pop %ebx <== NOT EXECUTED 10adbc: 5e pop %esi <== NOT EXECUTED 10adbd: 5f pop %edi <== NOT EXECUTED 10adbe: c9 leave <== NOT EXECUTED 10adbf: c3 ret <== NOT EXECUTED 0010adc0 <_Thread_Enable_dispatch>: */ #if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \ (__RTEMS_DO_NOT_INLINE_THREAD_ENABLE_DISPATCH__ == 1) ) void _Thread_Enable_dispatch( void ) { 10adc0: 55 push %ebp <== NOT EXECUTED 10adc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( --_Thread_Dispatch_disable_level ) 10adc3: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10adc8: 48 dec %eax <== NOT EXECUTED 10adc9: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED 10adce: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10add3: 85 c0 test %eax,%eax <== NOT EXECUTED 10add5: 75 06 jne 10addd <_Thread_Enable_dispatch+0x1d> <== NOT EXECUTED return; _Thread_Dispatch(); } 10add7: c9 leave <== NOT EXECUTED (__RTEMS_DO_NOT_INLINE_THREAD_ENABLE_DISPATCH__ == 1) ) void _Thread_Enable_dispatch( void ) { if ( --_Thread_Dispatch_disable_level ) return; _Thread_Dispatch(); 10add8: e9 9f fe ff ff jmp 10ac7c <_Thread_Dispatch> <== NOT EXECUTED } 10addd: c9 leave <== NOT EXECUTED 10adde: c3 ret <== NOT EXECUTED 0010e4e8 <_Thread_Evaluate_mode>: * * XXX */ bool _Thread_Evaluate_mode( void ) { 10e4e8: 55 push %ebp <== NOT EXECUTED 10e4e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 10e4eb: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED if ( !_States_Is_ready( executing->current_state ) || 10e4f0: 83 78 10 00 cmpl $0x0,0x10(%eax) <== NOT EXECUTED 10e4f4: 75 0e jne 10e504 <_Thread_Evaluate_mode+0x1c> <== NOT EXECUTED 10e4f6: 3b 05 8c ca 11 00 cmp 0x11ca8c,%eax <== NOT EXECUTED 10e4fc: 74 11 je 10e50f <_Thread_Evaluate_mode+0x27> <== NOT EXECUTED 10e4fe: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10e502: 74 0b je 10e50f <_Thread_Evaluate_mode+0x27> <== NOT EXECUTED ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) { _Context_Switch_necessary = TRUE; 10e504: c6 05 d0 ca 11 00 01 movb $0x1,0x11cad0 <== NOT EXECUTED 10e50b: b0 01 mov $0x1,%al <== NOT EXECUTED 10e50d: eb 02 jmp 10e511 <_Thread_Evaluate_mode+0x29> <== NOT EXECUTED return TRUE; 10e50f: 31 c0 xor %eax,%eax <== NOT EXECUTED } return FALSE; } 10e511: c9 leave <== NOT EXECUTED 10e512: c3 ret <== NOT EXECUTED 0010ade0 <_Thread_Get>: Thread_Control *_Thread_Get ( Objects_Id id, Objects_Locations *location ) { 10ade0: 55 push %ebp <== NOT EXECUTED 10ade1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ade3: 53 push %ebx <== NOT EXECUTED 10ade4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10ade7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10adea: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED uint32_t the_class; Objects_Information **api_information; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 10aded: 85 db test %ebx,%ebx <== NOT EXECUTED 10adef: 75 18 jne 10ae09 <_Thread_Get+0x29> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10adf1: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10adf6: 40 inc %eax <== NOT EXECUTED 10adf7: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; 10adfc: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED tp = _Thread_Executing; 10ae02: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 10ae07: eb 40 jmp 10ae49 <_Thread_Get+0x69> <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10ae09: 89 da mov %ebx,%edx <== NOT EXECUTED 10ae0b: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10ae0e: 83 e2 07 and $0x7,%edx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10ae11: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10ae14: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10ae17: 76 35 jbe 10ae4e <_Thread_Get+0x6e> <== NOT EXECUTED goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ *location = OBJECTS_ERROR; 10ae19: c7 01 01 00 00 00 movl $0x1,(%ecx) <== NOT EXECUTED 10ae1f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ae21: eb 26 jmp 10ae49 <_Thread_Get+0x69> <== NOT EXECUTED goto done; } api_information = _Objects_Information_table[ the_api ]; 10ae23: 8b 04 95 d4 c9 11 00 mov 0x11c9d4(,%edx,4),%eax <== NOT EXECUTED if ( !api_information ) { 10ae2a: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae2c: 74 07 je 10ae35 <_Thread_Get+0x55> <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = api_information[ the_class ]; 10ae2e: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED if ( !information ) { 10ae31: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae33: 75 08 jne 10ae3d <_Thread_Get+0x5d> <== NOT EXECUTED *location = OBJECTS_ERROR; 10ae35: c7 01 01 00 00 00 movl $0x1,(%ecx) <== NOT EXECUTED 10ae3b: eb 0c jmp 10ae49 <_Thread_Get+0x69> <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 10ae3d: 52 push %edx <== NOT EXECUTED 10ae3e: 51 push %ecx <== NOT EXECUTED 10ae3f: 53 push %ebx <== NOT EXECUTED 10ae40: 50 push %eax <== NOT EXECUTED 10ae41: e8 ba f7 ff ff call 10a600 <_Objects_Get> <== NOT EXECUTED 10ae46: 83 c4 10 add $0x10,%esp <== NOT EXECUTED done: return tp; } 10ae49: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ae4c: c9 leave <== NOT EXECUTED 10ae4d: c3 ret <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 10ae4e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10ae50: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED 10ae53: 48 dec %eax <== NOT EXECUTED 10ae54: 74 cd je 10ae23 <_Thread_Get+0x43> <== NOT EXECUTED 10ae56: eb c1 jmp 10ae19 <_Thread_Get+0x39> <== NOT EXECUTED 0010e514 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 10e514: 55 push %ebp <== NOT EXECUTED 10e515: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e517: 53 push %ebx <== NOT EXECUTED 10e518: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) static char doneConstructors; char doneCons; #endif executing = _Thread_Executing; 10e51b: 8b 1d c0 ca 11 00 mov 0x11cac0,%ebx <== NOT EXECUTED /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 10e521: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED _ISR_Set_level(level); 10e527: 85 c0 test %eax,%eax <== NOT EXECUTED 10e529: 74 03 je 10e52e <_Thread_Handler+0x1a> <== NOT EXECUTED 10e52b: fa cli <== NOT EXECUTED 10e52c: eb 01 jmp 10e52f <_Thread_Handler+0x1b> <== NOT EXECUTED 10e52e: fb sti <== NOT EXECUTED #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; 10e52f: a0 f8 c7 11 00 mov 0x11c7f8,%al <== NOT EXECUTED 10e534: 88 45 fb mov %al,-0x5(%ebp) <== NOT EXECUTED doneConstructors = 1; 10e537: c6 05 f8 c7 11 00 01 movb $0x1,0x11c7f8 <== NOT EXECUTED #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && !_Thread_Is_allocated_fp( executing ) ) { 10e53e: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx) <== NOT EXECUTED 10e545: 74 24 je 10e56b <_Thread_Handler+0x57> <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10e547: a1 84 ca 11 00 mov 0x11ca84,%eax <== NOT EXECUTED 10e54c: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10e54e: 74 1b je 10e56b <_Thread_Handler+0x57> <== NOT EXECUTED if ( _Thread_Allocated_fp != NULL ) 10e550: 85 c0 test %eax,%eax <== NOT EXECUTED 10e552: 74 11 je 10e565 <_Thread_Handler+0x51> <== NOT EXECUTED _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10e554: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e557: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10e55c: 50 push %eax <== NOT EXECUTED 10e55d: e8 c2 d8 ff ff call 10be24 <_CPU_Context_save_fp> <== NOT EXECUTED 10e562: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Allocated_fp = executing; 10e565: 89 1d 84 ca 11 00 mov %ebx,0x11ca84 <== NOT EXECUTED * 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 ); 10e56b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e56e: 53 push %ebx <== NOT EXECUTED 10e56f: e8 68 d4 ff ff call 10b9dc <_User_extensions_Thread_begin> <== NOT EXECUTED /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 10e574: e8 47 c8 ff ff call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED /* * _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 (!doneCons) /* && (volatile void *)_init) */ 10e579: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e57c: 80 7d fb 00 cmpb $0x0,-0x5(%ebp) <== NOT EXECUTED 10e580: 75 05 jne 10e587 <_Thread_Handler+0x73> <== NOT EXECUTED { _init (); 10e582: e8 69 6e 00 00 call 1153f0 <__start_set_sysctl_set> <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 10e587: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax <== NOT EXECUTED 10e58d: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10e590: 74 13 je 10e5a5 <_Thread_Handler+0x91> <== NOT EXECUTED 10e592: 72 0c jb 10e5a0 <_Thread_Handler+0x8c> <== NOT EXECUTED 10e594: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10e597: 74 11 je 10e5aa <_Thread_Handler+0x96> <== NOT EXECUTED 10e599: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10e59c: 75 36 jne 10e5d4 <_Thread_Handler+0xc0> <== NOT EXECUTED 10e59e: eb 1a jmp 10e5ba <_Thread_Handler+0xa6> <== NOT EXECUTED case THREAD_START_NUMERIC: executing->Wait.return_argument = 10e5a0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e5a3: eb 1d jmp 10e5c2 <_Thread_Handler+0xae> <== NOT EXECUTED (*(Thread_Entry_numeric) executing->Start.entry_point)( executing->Start.numeric_argument ); break; case THREAD_START_POINTER: executing->Wait.return_argument = 10e5a5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e5a8: eb 08 jmp 10e5b2 <_Thread_Handler+0x9e> <== NOT EXECUTED (*(Thread_Entry_pointer) executing->Start.entry_point)( executing->Start.pointer_argument ); break; case THREAD_START_BOTH_POINTER_FIRST: executing->Wait.return_argument = 10e5aa: 52 push %edx <== NOT EXECUTED 10e5ab: 52 push %edx <== NOT EXECUTED 10e5ac: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 10e5b2: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 10e5b8: eb 0e jmp 10e5c8 <_Thread_Handler+0xb4> <== NOT EXECUTED executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 10e5ba: 50 push %eax <== NOT EXECUTED 10e5bb: 50 push %eax <== NOT EXECUTED 10e5bc: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 10e5c2: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 10e5c8: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 10e5ce: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 10e5d1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * 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 ); 10e5d4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e5d7: 53 push %ebx <== NOT EXECUTED 10e5d8: e8 30 d4 ff ff call 10ba0d <_User_extensions_Thread_exitted> <== NOT EXECUTED _Internal_error_Occurred( 10e5dd: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10e5e0: 6a 06 push $0x6 <== NOT EXECUTED 10e5e2: 6a 01 push $0x1 <== NOT EXECUTED 10e5e4: 6a 00 push $0x0 <== NOT EXECUTED 10e5e6: e8 3d bb ff ff call 10a128 <_Internal_error_Occurred> <== NOT EXECUTED 0010b02c <_Thread_Handler_initialization>: #if defined(RTEMS_MULTIPROCESSING) , uint32_t maximum_proxies #endif ) { 10b02c: 55 push %ebp <== NOT EXECUTED 10b02d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b02f: 53 push %ebx <== NOT EXECUTED 10b030: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED /* * BOTH stacks hooks must be set or both must be NULL. * Do not allow mixture. */ if ( !( (!_Configuration_Table->stack_allocate_hook) 10b033: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 10b038: 83 78 20 00 cmpl $0x0,0x20(%eax) <== NOT EXECUTED 10b03c: 0f 94 c2 sete %dl <== NOT EXECUTED 10b03f: 83 78 24 00 cmpl $0x0,0x24(%eax) <== NOT EXECUTED 10b043: 0f 94 c0 sete %al <== NOT EXECUTED 10b046: 38 c2 cmp %al,%dl <== NOT EXECUTED 10b048: 74 0c je 10b056 <_Thread_Handler_initialization+0x2a> <== NOT EXECUTED == (!_Configuration_Table->stack_free_hook) ) ) _Internal_error_Occurred( 10b04a: 52 push %edx <== NOT EXECUTED 10b04b: 6a 0f push $0xf <== NOT EXECUTED 10b04d: 6a 01 push $0x1 <== NOT EXECUTED 10b04f: 6a 00 push $0x0 <== NOT EXECUTED 10b051: e8 d2 f0 ff ff call 10a128 <_Internal_error_Occurred> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 10b056: c6 05 d0 ca 11 00 00 movb $0x0,0x11cad0 <== NOT EXECUTED _Thread_Executing = NULL; 10b05d: c7 05 c0 ca 11 00 00 movl $0x0,0x11cac0 <== NOT EXECUTED 10b064: 00 00 00 <== NOT EXECUTED _Thread_Heir = NULL; 10b067: c7 05 8c ca 11 00 00 movl $0x0,0x11ca8c <== NOT EXECUTED 10b06e: 00 00 00 <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; 10b071: c7 05 84 ca 11 00 00 movl $0x0,0x11ca84 <== NOT EXECUTED 10b078: 00 00 00 <== NOT EXECUTED #endif _Thread_Do_post_task_switch_extension = 0; 10b07b: c7 05 a4 ca 11 00 00 movl $0x0,0x11caa4 <== NOT EXECUTED 10b082: 00 00 00 <== NOT EXECUTED _Thread_Maximum_extensions = maximum_extensions; 10b085: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b088: a3 a0 ca 11 00 mov %eax,0x11caa0 <== NOT EXECUTED _Thread_Ticks_per_timeslice = ticks_per_timeslice; 10b08d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b090: a3 cc c9 11 00 mov %eax,0x11c9cc <== NOT EXECUTED _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error( 10b095: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b098: 0f b6 05 84 86 11 00 movzbl 0x118684,%eax <== NOT EXECUTED 10b09f: 40 inc %eax <== NOT EXECUTED 10b0a0: 6b c0 0c imul $0xc,%eax,%eax <== NOT EXECUTED 10b0a3: 50 push %eax <== NOT EXECUTED 10b0a4: e8 c9 0c 00 00 call 10bd72 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10b0a9: a3 c8 c9 11 00 mov %eax,0x11c9c8 <== NOT EXECUTED (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control) ); for ( index=0; index <= PRIORITY_MAXIMUM ; index++ ) 10b0ae: 0f b6 1d 84 86 11 00 movzbl 0x118684,%ebx <== NOT EXECUTED 10b0b5: 89 c2 mov %eax,%edx <== NOT EXECUTED 10b0b7: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10b0b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b0bc: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10b0bf: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10b0c1: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10b0c8: 89 52 08 mov %edx,0x8(%edx) <== NOT EXECUTED 10b0cb: 41 inc %ecx <== NOT EXECUTED 10b0cc: 83 c2 0c add $0xc,%edx <== NOT EXECUTED 10b0cf: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 10b0d1: 76 e9 jbe 10b0bc <_Thread_Handler_initialization+0x90> <== NOT EXECUTED /* * Initialize this class of objects. */ _Objects_Initialize_information( 10b0d3: 50 push %eax <== NOT EXECUTED 10b0d4: 6a 08 push $0x8 <== NOT EXECUTED 10b0d6: 6a 01 push $0x1 <== NOT EXECUTED 10b0d8: 68 08 01 00 00 push $0x108 <== NOT EXECUTED 10b0dd: 6a 01 push $0x1 <== NOT EXECUTED 10b0df: 6a 01 push $0x1 <== NOT EXECUTED 10b0e1: 6a 01 push $0x1 <== NOT EXECUTED 10b0e3: 68 5c cb 11 00 push $0x11cb5c <== NOT EXECUTED 10b0e8: e8 6b f5 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED 10b0ed: 83 c4 20 add $0x20,%esp <== NOT EXECUTED FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10b0f0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b0f3: c9 leave <== NOT EXECUTED 10b0f4: c3 ret <== NOT EXECUTED 0010ae58 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10ae58: 55 push %ebp <== NOT EXECUTED 10ae59: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae5b: 57 push %edi <== NOT EXECUTED 10ae5c: 56 push %esi <== NOT EXECUTED 10ae5d: 53 push %ebx <== NOT EXECUTED 10ae5e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae61: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10ae64: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10ae67: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 10ae6a: 8a 45 18 mov 0x18(%ebp),%al <== NOT EXECUTED 10ae6d: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED 10ae70: 8a 45 20 mov 0x20(%ebp),%al <== NOT EXECUTED 10ae73: 88 45 f2 mov %al,-0xe(%ebp) <== NOT EXECUTED /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 10ae76: 85 d2 test %edx,%edx <== NOT EXECUTED 10ae78: 75 2a jne 10aea4 <_Thread_Initialize+0x4c> <== NOT EXECUTED actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10ae7a: 51 push %ecx <== NOT EXECUTED 10ae7b: 51 push %ecx <== NOT EXECUTED 10ae7c: 56 push %esi <== NOT EXECUTED 10ae7d: 53 push %ebx <== NOT EXECUTED 10ae7e: e8 69 08 00 00 call 10b6ec <_Thread_Stack_Allocate> <== NOT EXECUTED if ( !actual_stack_size || actual_stack_size < stack_size ) 10ae83: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae86: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae88: 74 04 je 10ae8e <_Thread_Initialize+0x36> <== NOT EXECUTED 10ae8a: 39 f0 cmp %esi,%eax <== NOT EXECUTED 10ae8c: 73 07 jae 10ae95 <_Thread_Initialize+0x3d> <== NOT EXECUTED 10ae8e: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ae90: e9 8c 01 00 00 jmp 10b021 <_Thread_Initialize+0x1c9> <== NOT EXECUTED return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 10ae95: 8b 93 d0 00 00 00 mov 0xd0(%ebx),%edx <== NOT EXECUTED the_thread->Start.core_allocated_stack = TRUE; 10ae9b: c6 83 c0 00 00 00 01 movb $0x1,0xc0(%ebx) <== NOT EXECUTED 10aea2: eb 09 jmp 10aead <_Thread_Initialize+0x55> <== NOT EXECUTED } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = FALSE; 10aea4: c6 83 c0 00 00 00 00 movb $0x0,0xc0(%ebx) <== NOT EXECUTED 10aeab: 89 f0 mov %esi,%eax <== NOT EXECUTED /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of 10aead: 89 93 c8 00 00 00 mov %edx,0xc8(%ebx) <== NOT EXECUTED * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 10aeb3: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx) <== NOT EXECUTED if ( is_fp ) { fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); if ( !fp_area ) { _Thread_Stack_Free( the_thread ); return FALSE; 10aeb9: 31 f6 xor %esi,%esi <== NOT EXECUTED /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 10aebb: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10aebf: 74 17 je 10aed8 <_Thread_Initialize+0x80> <== NOT EXECUTED fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10aec1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aec4: 6a 6c push $0x6c <== NOT EXECUTED 10aec6: e8 92 0e 00 00 call 10bd5d <_Workspace_Allocate> <== NOT EXECUTED 10aecb: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( !fp_area ) { 10aecd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aed0: 85 c0 test %eax,%eax <== NOT EXECUTED 10aed2: 0f 84 3b 01 00 00 je 10b013 <_Thread_Initialize+0x1bb> <== NOT EXECUTED fp_area = _Context_Fp_start( fp_area, 0 ); } else fp_area = NULL; the_thread->fp_context = fp_area; 10aed8: 89 b3 ec 00 00 00 mov %esi,0xec(%ebx) <== NOT EXECUTED the_thread->Start.fp_context = fp_area; 10aede: 89 b3 cc 00 00 00 mov %esi,0xcc(%ebx) <== NOT EXECUTED * 10aee4: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10aeeb: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10aef2: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) <== NOT EXECUTED * the heap 10aef9: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED /* * Clear the libc reent hook. */ the_thread->libc_reent = NULL; 10af00: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx) <== NOT EXECUTED 10af07: 00 00 00 <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10af0a: a1 a0 ca 11 00 mov 0x11caa0,%eax <== NOT EXECUTED (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); return FALSE; 10af0f: 31 ff xor %edi,%edi <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10af11: 85 c0 test %eax,%eax <== NOT EXECUTED 10af13: 74 1d je 10af32 <_Thread_Initialize+0xda> <== NOT EXECUTED extensions_area = _Workspace_Allocate( 10af15: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af18: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax <== NOT EXECUTED 10af1f: 50 push %eax <== NOT EXECUTED 10af20: e8 38 0e 00 00 call 10bd5d <_Workspace_Allocate> <== NOT EXECUTED 10af25: 89 c7 mov %eax,%edi <== NOT EXECUTED (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 10af27: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af2a: 85 c0 test %eax,%eax <== NOT EXECUTED 10af2c: 0f 84 d1 00 00 00 je 10b003 <_Thread_Initialize+0x1ab> <== NOT EXECUTED return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 10af32: 89 bb 00 01 00 00 mov %edi,0x100(%ebx) <== NOT EXECUTED * create the extension long after tasks have been created * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { 10af38: 31 d2 xor %edx,%edx <== NOT EXECUTED 10af3a: 85 ff test %edi,%edi <== NOT EXECUTED 10af3c: 75 10 jne 10af4e <_Thread_Initialize+0xf6> <== NOT EXECUTED 10af3e: eb 18 jmp 10af58 <_Thread_Initialize+0x100> <== NOT EXECUTED uint32_t i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) the_thread->extensions[i] = NULL; 10af40: 8b 83 00 01 00 00 mov 0x100(%ebx),%eax <== NOT EXECUTED 10af46: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) <== NOT EXECUTED * call. */ if ( the_thread->extensions ) { uint32_t i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 10af4d: 42 inc %edx <== NOT EXECUTED 10af4e: a1 a0 ca 11 00 mov 0x11caa0,%eax <== NOT EXECUTED 10af53: 40 inc %eax <== NOT EXECUTED 10af54: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10af56: 72 e8 jb 10af40 <_Thread_Initialize+0xe8> <== NOT EXECUTED /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10af58: 8a 45 f2 mov -0xe(%ebp),%al <== NOT EXECUTED 10af5b: 88 83 ac 00 00 00 mov %al,0xac(%ebx) <== NOT EXECUTED the_thread->Start.budget_algorithm = budget_algorithm; 10af61: 8b 45 24 mov 0x24(%ebp),%eax <== NOT EXECUTED 10af64: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx) <== NOT EXECUTED the_thread->Start.budget_callout = budget_callout; 10af6a: 8b 45 28 mov 0x28(%ebp),%eax <== NOT EXECUTED 10af6d: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx) <== NOT EXECUTED switch ( budget_algorithm ) { 10af73: 83 7d 24 02 cmpl $0x2,0x24(%ebp) <== NOT EXECUTED 10af77: 75 08 jne 10af81 <_Thread_Initialize+0x129> <== NOT EXECUTED case THREAD_CPU_BUDGET_ALGORITHM_NONE: case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: break; case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10af79: a1 cc c9 11 00 mov 0x11c9cc,%eax <== NOT EXECUTED 10af7e: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 10af81: 8b 45 2c mov 0x2c(%ebp),%eax <== NOT EXECUTED 10af84: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED the_thread->current_state = STATES_DORMANT; 10af8a: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) <== NOT EXECUTED the_thread->Wait.queue = NULL; 10af91: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED the_thread->resource_count = 0; 10af98: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) <== NOT EXECUTED the_thread->suspend_count = 0; 10af9f: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED the_thread->real_priority = priority; 10afa6: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 10afa9: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED the_thread->Start.initial_priority = priority; 10afac: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) <== NOT EXECUTED _Thread_Set_priority( the_thread, priority ); 10afb2: 52 push %edx <== NOT EXECUTED 10afb3: 52 push %edx <== NOT EXECUTED 10afb4: 50 push %eax <== NOT EXECUTED 10afb5: 53 push %ebx <== NOT EXECUTED 10afb6: e8 8d 05 00 00 call 10b548 <_Thread_Set_priority> <== NOT EXECUTED /* * Initialize the CPU usage statistics */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS the_thread->cpu_time_used.tv_sec = 0; 10afbb: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) <== NOT EXECUTED 10afc2: 00 00 00 <== NOT EXECUTED the_thread->cpu_time_used.tv_nsec = 0; 10afc5: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) <== NOT EXECUTED 10afcc: 00 00 00 <== NOT EXECUTED 10afcf: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 10afd3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10afd6: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10afd9: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10afdc: 8b 45 30 mov 0x30(%ebp),%eax <== NOT EXECUTED 10afdf: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED * 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 ); 10afe2: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10afe5: e8 92 0a 00 00 call 10ba7c <_User_extensions_Thread_create> <== NOT EXECUTED if ( !extension_status ) { 10afea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10afed: b2 01 mov $0x1,%dl <== NOT EXECUTED 10afef: 84 c0 test %al,%al <== NOT EXECUTED 10aff1: 75 2e jne 10b021 <_Thread_Initialize+0x1c9> <== NOT EXECUTED if ( extensions_area ) 10aff3: 85 ff test %edi,%edi <== NOT EXECUTED 10aff5: 74 0c je 10b003 <_Thread_Initialize+0x1ab> <== NOT EXECUTED (void) _Workspace_Free( extensions_area ); 10aff7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10affa: 57 push %edi <== NOT EXECUTED 10affb: e8 48 0d 00 00 call 10bd48 <_Workspace_Free> <== NOT EXECUTED 10b000: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 10b003: 85 f6 test %esi,%esi <== NOT EXECUTED 10b005: 74 0c je 10b013 <_Thread_Initialize+0x1bb> <== NOT EXECUTED (void) _Workspace_Free( fp_area ); 10b007: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b00a: 56 push %esi <== NOT EXECUTED 10b00b: e8 38 0d 00 00 call 10bd48 <_Workspace_Free> <== NOT EXECUTED 10b010: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif _Thread_Stack_Free( the_thread ); 10b013: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b016: 53 push %ebx <== NOT EXECUTED 10b017: e8 20 07 00 00 call 10b73c <_Thread_Stack_Free> <== NOT EXECUTED 10b01c: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b01e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return FALSE; } return TRUE; } 10b021: 88 d0 mov %dl,%al <== NOT EXECUTED 10b023: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b026: 5b pop %ebx <== NOT EXECUTED 10b027: 5e pop %esi <== NOT EXECUTED 10b028: 5f pop %edi <== NOT EXECUTED 10b029: c9 leave <== NOT EXECUTED 10b02a: c3 ret <== NOT EXECUTED 0010daa0 <_Thread_Load_environment>: */ void _Thread_Load_environment( Thread_Control *the_thread ) { 10daa0: 55 push %ebp <== NOT EXECUTED 10daa1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10daa3: 57 push %edi <== NOT EXECUTED 10daa4: 56 push %esi <== NOT EXECUTED 10daa5: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10daa8: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED bool is_fp; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( the_thread->Start.fp_context ) { 10daab: 8b ba cc 00 00 00 mov 0xcc(%edx),%edi <== NOT EXECUTED 10dab1: 85 ff test %edi,%edi <== NOT EXECUTED 10dab3: 74 12 je 10dac7 <_Thread_Load_environment+0x27> <== NOT EXECUTED the_thread->fp_context = the_thread->Start.fp_context; 10dab5: 89 ba ec 00 00 00 mov %edi,0xec(%edx) <== NOT EXECUTED _Context_Initialize_fp( &the_thread->fp_context ); 10dabb: be ac cb 11 00 mov $0x11cbac,%esi <== NOT EXECUTED 10dac0: b9 1b 00 00 00 mov $0x1b,%ecx <== NOT EXECUTED 10dac5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED } else #endif is_fp = false; the_thread->do_post_task_switch_extension = false; 10dac7: c6 42 75 00 movb $0x0,0x75(%edx) <== NOT EXECUTED the_thread->is_preemptible = the_thread->Start.is_preemptible; 10dacb: 8a 82 ac 00 00 00 mov 0xac(%edx),%al <== NOT EXECUTED 10dad1: 88 42 76 mov %al,0x76(%edx) <== NOT EXECUTED the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 10dad4: 8b 82 b0 00 00 00 mov 0xb0(%edx),%eax <== NOT EXECUTED 10dada: 89 42 7c mov %eax,0x7c(%edx) <== NOT EXECUTED the_thread->budget_callout = the_thread->Start.budget_callout; 10dadd: 8b 82 b4 00 00 00 mov 0xb4(%edx),%eax <== NOT EXECUTED 10dae3: 89 82 80 00 00 00 mov %eax,0x80(%edx) <== NOT EXECUTED _Context_Initialize( 10dae9: 83 ba b8 00 00 00 01 cmpl $0x1,0xb8(%edx) <== NOT EXECUTED 10daf0: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10daf2: 25 00 02 00 00 and $0x200,%eax <== NOT EXECUTED 10daf7: 05 02 30 00 00 add $0x3002,%eax <== NOT EXECUTED 10dafc: 89 82 d4 00 00 00 mov %eax,0xd4(%edx) <== NOT EXECUTED 10db02: 8b 82 c4 00 00 00 mov 0xc4(%edx),%eax <== NOT EXECUTED 10db08: 83 e8 04 sub $0x4,%eax <== NOT EXECUTED 10db0b: 03 82 c8 00 00 00 add 0xc8(%edx),%eax <== NOT EXECUTED 10db11: c7 00 14 e5 10 00 movl $0x10e514,(%eax) <== NOT EXECUTED 10db17: 89 82 dc 00 00 00 mov %eax,0xdc(%edx) <== NOT EXECUTED 10db1d: 89 82 d8 00 00 00 mov %eax,0xd8(%edx) <== NOT EXECUTED the_thread->Start.isr_level, _Thread_Handler, is_fp ); } 10db23: 58 pop %eax <== NOT EXECUTED 10db24: 5e pop %esi <== NOT EXECUTED 10db25: 5f pop %edi <== NOT EXECUTED 10db26: c9 leave <== NOT EXECUTED 10db27: c3 ret <== NOT EXECUTED 0010dd04 <_Thread_Ready>: */ void _Thread_Ready( Thread_Control *the_thread ) { 10dd04: 55 push %ebp <== NOT EXECUTED 10dd05: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dd07: 53 push %ebx <== NOT EXECUTED 10dd08: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Thread_Control *heir; _ISR_Disable( level ); 10dd0b: 9c pushf <== NOT EXECUTED 10dd0c: fa cli <== NOT EXECUTED 10dd0d: 5b pop %ebx <== NOT EXECUTED the_thread->current_state = STATES_READY; 10dd0e: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx) <== NOT EXECUTED * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in 10dd15: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10dd1b: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10dd22: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10dd25: 66 a1 b4 ca 11 00 mov 0x11cab4,%ax <== NOT EXECUTED 10dd2b: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10dd31: 66 a3 b4 ca 11 00 mov %ax,0x11cab4 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node ); 10dd37: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10dd3d: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10dd40: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10dd42: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10dd45: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10dd48: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10dd4a: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10dd4d: 53 push %ebx <== NOT EXECUTED 10dd4e: 9d popf <== NOT EXECUTED 10dd4f: fa cli <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10dd50: 66 8b 0d b4 ca 11 00 mov 0x11cab4,%cx <== NOT EXECUTED 10dd57: 31 d2 xor %edx,%edx <== NOT EXECUTED 10dd59: 89 d0 mov %edx,%eax <== NOT EXECUTED 10dd5b: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10dd5f: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10dd62: 66 8b 8c 00 2c cb 11 mov 0x11cb2c(%eax,%eax,1),%cx <== NOT EXECUTED 10dd69: 00 <== NOT EXECUTED 10dd6a: 66 0f bc d1 bsf %cx,%dx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10dd6e: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10dd71: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10dd74: 01 d0 add %edx,%eax <== NOT EXECUTED 10dd76: 6b c0 0c imul $0xc,%eax,%eax <== NOT EXECUTED 10dd79: 8b 15 c8 c9 11 00 mov 0x11c9c8,%edx <== NOT EXECUTED 10dd7f: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10dd82: a3 8c ca 11 00 mov %eax,0x11ca8c <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10dd87: 8b 15 c0 ca 11 00 mov 0x11cac0,%edx <== NOT EXECUTED _Thread_Calculate_heir(); heir = _Thread_Heir; if ( !_Thread_Is_executing( heir ) && _Thread_Executing->is_preemptible ) 10dd8d: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10dd8f: 74 0d je 10dd9e <_Thread_Ready+0x9a> <== NOT EXECUTED 10dd91: 80 7a 76 00 cmpb $0x0,0x76(%edx) <== NOT EXECUTED 10dd95: 74 07 je 10dd9e <_Thread_Ready+0x9a> <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10dd97: c6 05 d0 ca 11 00 01 movb $0x1,0x11cad0 <== NOT EXECUTED _ISR_Enable( level ); 10dd9e: 53 push %ebx <== NOT EXECUTED 10dd9f: 9d popf <== NOT EXECUTED } 10dda0: 5b pop %ebx <== NOT EXECUTED 10dda1: c9 leave <== NOT EXECUTED 10dda2: c3 ret <== NOT EXECUTED 0010e87c <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10e87c: 55 push %ebp <== NOT EXECUTED 10e87d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e87f: 53 push %ebx <== NOT EXECUTED 10e880: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10e883: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED the_thread->resource_count = 0; 10e886: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) <== NOT EXECUTED the_thread->suspend_count = 0; 10e88d: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED the_thread->is_preemptible = the_thread->Start.is_preemptible; 10e894: 8a 83 ac 00 00 00 mov 0xac(%ebx),%al <== NOT EXECUTED 10e89a: 88 43 76 mov %al,0x76(%ebx) <== NOT EXECUTED the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 10e89d: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 10e8a3: 89 43 7c mov %eax,0x7c(%ebx) <== NOT EXECUTED the_thread->budget_callout = the_thread->Start.budget_callout; 10e8a6: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax <== NOT EXECUTED 10e8ac: 89 83 80 00 00 00 mov %eax,0x80(%ebx) <== NOT EXECUTED the_thread->Start.pointer_argument = pointer_argument; 10e8b2: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e8b5: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) <== NOT EXECUTED the_thread->Start.numeric_argument = numeric_argument; 10e8bb: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10e8be: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) <== NOT EXECUTED if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 10e8c4: 53 push %ebx <== NOT EXECUTED 10e8c5: e8 c6 d4 ff ff call 10bd90 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 10e8ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e8cd: 84 c0 test %al,%al <== NOT EXECUTED 10e8cf: 75 15 jne 10e8e6 <_Thread_Reset+0x6a> <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 10e8d1: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10e8d5: 75 0f jne 10e8e6 <_Thread_Reset+0x6a> <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10e8d7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e8da: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10e8dd: 50 push %eax <== NOT EXECUTED 10e8de: e8 ed dd ff ff call 10c6d0 <_Watchdog_Remove> <== NOT EXECUTED 10e8e3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 10e8e6: 8b 83 bc 00 00 00 mov 0xbc(%ebx),%eax <== NOT EXECUTED 10e8ec: 39 43 14 cmp %eax,0x14(%ebx) <== NOT EXECUTED 10e8ef: 74 12 je 10e903 <_Thread_Reset+0x87> <== NOT EXECUTED the_thread->real_priority = the_thread->Start.initial_priority; 10e8f1: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 10e8f4: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10e8f7: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 10e8fa: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e8fd: c9 leave <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { the_thread->real_priority = the_thread->Start.initial_priority; _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 10e8fe: e9 69 d6 ff ff jmp 10bf6c <_Thread_Set_priority> <== NOT EXECUTED } } 10e903: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e906: c9 leave <== NOT EXECUTED 10e907: c3 ret <== NOT EXECUTED 0010dda4 <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 10dda4: 55 push %ebp <== NOT EXECUTED 10dda5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dda7: 56 push %esi <== NOT EXECUTED 10dda8: 53 push %ebx <== NOT EXECUTED ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10dda9: 8b 0d c0 ca 11 00 mov 0x11cac0,%ecx <== NOT EXECUTED ready = executing->ready; 10ddaf: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx <== NOT EXECUTED _ISR_Disable( level ); 10ddb5: 9c pushf <== NOT EXECUTED 10ddb6: fa cli <== NOT EXECUTED 10ddb7: 5e pop %esi <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10ddb8: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10ddba: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10ddbd: 75 04 jne 10ddc3 <_Thread_Reset_timeslice+0x1f> <== NOT EXECUTED _ISR_Enable( level ); 10ddbf: 56 push %esi <== NOT EXECUTED 10ddc0: 9d popf <== NOT EXECUTED 10ddc1: eb 35 jmp 10ddf8 <_Thread_Reset_timeslice+0x54> <== NOT EXECUTED 10ddc3: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10ddc5: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10ddc8: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10ddcb: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10ddcd: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 10ddd0: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10ddd2: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10ddd5: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED 10ddd8: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10ddda: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED return; } _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 10dddd: 56 push %esi <== NOT EXECUTED 10ddde: 9d popf <== NOT EXECUTED 10dddf: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( executing ) ) 10dde0: 3b 0d 8c ca 11 00 cmp 0x11ca8c,%ecx <== NOT EXECUTED 10dde6: 75 07 jne 10ddef <_Thread_Reset_timeslice+0x4b> <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 10dde8: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10ddea: a3 8c ca 11 00 mov %eax,0x11ca8c <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10ddef: c6 05 d0 ca 11 00 01 movb $0x1,0x11cad0 <== NOT EXECUTED _ISR_Enable( level ); 10ddf6: 56 push %esi <== NOT EXECUTED 10ddf7: 9d popf <== NOT EXECUTED } 10ddf8: 5b pop %ebx <== NOT EXECUTED 10ddf9: 5e pop %esi <== NOT EXECUTED 10ddfa: c9 leave <== NOT EXECUTED 10ddfb: c3 ret <== NOT EXECUTED 0010bee4 <_Thread_Restart>: bool _Thread_Restart( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10bee4: 55 push %ebp <== NOT EXECUTED 10bee5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bee7: 53 push %ebx <== NOT EXECUTED 10bee8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10beeb: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( !_States_Is_dormant( the_thread->current_state ) ) { 10beee: 31 c0 xor %eax,%eax <== NOT EXECUTED 10bef0: f6 43 10 01 testb $0x1,0x10(%ebx) <== NOT EXECUTED 10bef4: 75 70 jne 10bf66 <_Thread_Restart+0x82> <== NOT EXECUTED _Thread_Set_transient( the_thread ); 10bef6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bef9: 53 push %ebx <== NOT EXECUTED 10befa: e8 a1 01 00 00 call 10c0a0 <_Thread_Set_transient> <== NOT EXECUTED _Thread_Reset( the_thread, pointer_argument, numeric_argument ); 10beff: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10bf02: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10bf05: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10bf08: 53 push %ebx <== NOT EXECUTED 10bf09: e8 6e 29 00 00 call 10e87c <_Thread_Reset> <== NOT EXECUTED _Thread_Load_environment( the_thread ); 10bf0e: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10bf11: e8 62 26 00 00 call 10e578 <_Thread_Load_environment> <== NOT EXECUTED _Thread_Ready( the_thread ); 10bf16: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10bf19: e8 be 28 00 00 call 10e7dc <_Thread_Ready> <== NOT EXECUTED _User_extensions_Thread_restart( the_thread ); 10bf1e: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10bf21: e8 ee 05 00 00 call 10c514 <_User_extensions_Thread_restart> <== NOT EXECUTED if ( _Thread_Is_executing ( the_thread ) ) 10bf26: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bf29: b0 01 mov $0x1,%al <== NOT EXECUTED 10bf2b: 3b 1d 2c fb 11 00 cmp 0x11fb2c,%ebx <== NOT EXECUTED 10bf31: 75 33 jne 10bf66 <_Thread_Restart+0x82> <== NOT EXECUTED * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @param[in] alignment the required alignment 10bf33: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx) <== NOT EXECUTED 10bf3a: 74 12 je 10bf4e <_Thread_Restart+0x6a> <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10bf3c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bf3f: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax <== NOT EXECUTED 10bf45: 50 push %eax <== NOT EXECUTED 10bf46: e8 43 09 00 00 call 10c88e <_CPU_Context_restore_fp> <== NOT EXECUTED 10bf4b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, 10bf4e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bf51: a1 2c fb 11 00 mov 0x11fb2c,%eax <== NOT EXECUTED 10bf56: 05 d4 00 00 00 add $0xd4,%eax <== NOT EXECUTED 10bf5b: 50 push %eax <== NOT EXECUTED 10bf5c: e8 1c 09 00 00 call 10c87d <_CPU_Context_restore> <== NOT EXECUTED 10bf61: b0 01 mov $0x1,%al <== NOT EXECUTED 10bf63: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return TRUE; } return FALSE; } 10bf66: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bf69: c9 leave <== NOT EXECUTED 10bf6a: c3 ret <== NOT EXECUTED 0010c8f4 <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, bool force ) { 10c8f4: 55 push %ebp <== NOT EXECUTED 10c8f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c8f7: 53 push %ebx <== NOT EXECUTED 10c8f8: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c8fb: 8a 45 0c mov 0xc(%ebp),%al <== NOT EXECUTED ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10c8fe: 9c pushf <== NOT EXECUTED 10c8ff: fa cli <== NOT EXECUTED 10c900: 5b pop %ebx <== NOT EXECUTED if ( force == TRUE ) 10c901: 84 c0 test %al,%al <== NOT EXECUTED 10c903: 74 09 je 10c90e <_Thread_Resume+0x1a> <== NOT EXECUTED the_thread->suspend_count = 0; 10c905: c7 41 70 00 00 00 00 movl $0x0,0x70(%ecx) <== NOT EXECUTED 10c90c: eb 03 jmp 10c911 <_Thread_Resume+0x1d> <== NOT EXECUTED else the_thread->suspend_count--; 10c90e: ff 49 70 decl 0x70(%ecx) <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 10c911: 83 79 70 00 cmpl $0x0,0x70(%ecx) <== NOT EXECUTED 10c915: 74 04 je 10c91b <_Thread_Resume+0x27> <== NOT EXECUTED _ISR_Enable( level ); 10c917: 53 push %ebx <== NOT EXECUTED 10c918: 9d popf <== NOT EXECUTED 10c919: eb 77 jmp 10c992 <_Thread_Resume+0x9e> <== NOT EXECUTED return; } current_state = the_thread->current_state; 10c91b: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED if ( current_state & STATES_SUSPENDED ) { 10c91e: a8 02 test $0x2,%al <== NOT EXECUTED 10c920: 74 6e je 10c990 <_Thread_Resume+0x9c> <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 10c922: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED current_state = 10c925: 89 41 10 mov %eax,0x10(%ecx) <== NOT EXECUTED the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); if ( _States_Is_ready( current_state ) ) { 10c928: 85 c0 test %eax,%eax <== NOT EXECUTED 10c92a: 75 64 jne 10c990 <_Thread_Resume+0x9c> <== NOT EXECUTED * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in 10c92c: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10c932: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10c939: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10c93c: 66 a1 70 84 12 00 mov 0x128470,%ax <== NOT EXECUTED 10c942: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10c948: 66 a3 70 84 12 00 mov %ax,0x128470 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10c94e: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10c954: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10c957: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10c959: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10c95c: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10c95f: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10c961: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10c964: 53 push %ebx <== NOT EXECUTED 10c965: 9d popf <== NOT EXECUTED 10c966: fa cli <== NOT EXECUTED if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 10c967: 8b 51 14 mov 0x14(%ecx),%edx <== NOT EXECUTED 10c96a: a1 48 84 12 00 mov 0x128448,%eax <== NOT EXECUTED 10c96f: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10c972: 73 1c jae 10c990 <_Thread_Resume+0x9c> <== NOT EXECUTED _Thread_Heir = the_thread; 10c974: 89 0d 48 84 12 00 mov %ecx,0x128448 <== NOT EXECUTED if ( _Thread_Executing->is_preemptible || 10c97a: a1 7c 84 12 00 mov 0x12847c,%eax <== NOT EXECUTED 10c97f: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10c983: 75 04 jne 10c989 <_Thread_Resume+0x95> <== NOT EXECUTED 10c985: 85 d2 test %edx,%edx <== NOT EXECUTED 10c987: 75 07 jne 10c990 <_Thread_Resume+0x9c> <== NOT EXECUTED the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 10c989: c6 05 8c 84 12 00 01 movb $0x1,0x12848c <== NOT EXECUTED } } } _ISR_Enable( level ); 10c990: 53 push %ebx <== NOT EXECUTED 10c991: 9d popf <== NOT EXECUTED } 10c992: 5b pop %ebx <== NOT EXECUTED 10c993: c9 leave <== NOT EXECUTED 10c994: c3 ret <== NOT EXECUTED 0010b548 <_Thread_Set_priority>: void _Thread_Set_priority( Thread_Control *the_thread, Priority_Control new_priority ) { 10b548: 55 push %ebp <== NOT EXECUTED 10b549: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b54b: 56 push %esi <== NOT EXECUTED 10b54c: 53 push %ebx <== NOT EXECUTED 10b54d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b550: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED the_thread->current_priority = new_priority; 10b553: 89 5a 14 mov %ebx,0x14(%edx) <== NOT EXECUTED the_thread->ready = &_Thread_Ready_chain[ new_priority ]; 10b556: 6b c3 0c imul $0xc,%ebx,%eax <== NOT EXECUTED 10b559: 03 05 c8 c9 11 00 add 0x11c9c8,%eax <== NOT EXECUTED 10b55f: 89 82 8c 00 00 00 mov %eax,0x8c(%edx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon * @param[in] source is a user specified integer which may be used to * indicate where in the application this was invoked from * @param[in] do_dump is set to TRUE if errors should be printed * @return TRUE if the test passed fine, FALSE otherwise. */ 10b565: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 10b567: c1 e9 04 shr $0x4,%ecx <== NOT EXECUTED bool _Protected_heap_Walk( Heap_Control *the_heap, int source, 10b56a: 0f b7 c9 movzwl %cx,%ecx <== NOT EXECUTED 10b56d: 8d 84 09 2c cb 11 00 lea 0x11cb2c(%ecx,%ecx,1),%eax <== NOT EXECUTED 10b574: 89 82 90 00 00 00 mov %eax,0x90(%edx) <== NOT EXECUTED bool do_dump ); 10b57a: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10b57f: 89 c6 mov %eax,%esi <== NOT EXECUTED 10b581: d3 e6 shl %cl,%esi <== NOT EXECUTED 10b583: 89 f1 mov %esi,%ecx <== NOT EXECUTED /** 10b585: 66 89 b2 94 00 00 00 mov %si,0x94(%edx) <== NOT EXECUTED * This routine walks the heap and tots up the free and allocated 10b58c: f7 d1 not %ecx <== NOT EXECUTED 10b58e: 66 89 8a 98 00 00 00 mov %cx,0x98(%edx) <== NOT EXECUTED * sizes. * 10b595: 83 e3 0f and $0xf,%ebx <== NOT EXECUTED 10b598: 88 d9 mov %bl,%cl <== NOT EXECUTED 10b59a: d3 e0 shl %cl,%eax <== NOT EXECUTED * @param[in] the_heap pointer to heap header 10b59c: 66 89 82 96 00 00 00 mov %ax,0x96(%edx) <== NOT EXECUTED * @param[in] the_info pointer to a status information area 10b5a3: f7 d0 not %eax <== NOT EXECUTED 10b5a5: 66 89 82 9a 00 00 00 mov %ax,0x9a(%edx) <== NOT EXECUTED _Priority_Initialize_information( &the_thread->Priority_map, new_priority ); } 10b5ac: 5b pop %ebx <== NOT EXECUTED 10b5ad: 5e pop %esi <== NOT EXECUTED 10b5ae: c9 leave <== NOT EXECUTED 10b5af: c3 ret <== NOT EXECUTED 0010b5b0 <_Thread_Set_state>: void _Thread_Set_state( Thread_Control *the_thread, States_Control state ) { 10b5b0: 55 push %ebp <== NOT EXECUTED 10b5b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b5b3: 56 push %esi <== NOT EXECUTED 10b5b4: 53 push %ebx <== NOT EXECUTED 10b5b5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b5b8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED ISR_Level level; Chain_Control *ready; ready = the_thread->ready; 10b5bb: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx <== NOT EXECUTED _ISR_Disable( level ); 10b5c1: 9c pushf <== NOT EXECUTED 10b5c2: fa cli <== NOT EXECUTED 10b5c3: 5e pop %esi <== NOT EXECUTED if ( !_States_Is_ready( the_thread->current_state ) ) { 10b5c4: 8b 4b 10 mov 0x10(%ebx),%ecx <== NOT EXECUTED 10b5c7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b5c9: 74 0c je 10b5d7 <_Thread_Set_state+0x27> <== NOT EXECUTED the_thread->current_state = 10b5cb: 09 c8 or %ecx,%eax <== NOT EXECUTED 10b5cd: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _States_Set( state, the_thread->current_state ); _ISR_Enable( level ); 10b5d0: 56 push %esi <== NOT EXECUTED 10b5d1: 9d popf <== NOT EXECUTED 10b5d2: e9 a0 00 00 00 jmp 10b677 <_Thread_Set_state+0xc7> <== NOT EXECUTED return; } the_thread->current_state = state; 10b5d7: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10b5da: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10b5dc: 3b 42 08 cmp 0x8(%edx),%eax <== NOT EXECUTED 10b5df: 75 39 jne 10b61a <_Thread_Set_state+0x6a> <== NOT EXECUTED 10b5e1: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10b5e4: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10b5e6: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10b5ed: 89 52 08 mov %edx,0x8(%edx) <== NOT EXECUTED /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. * * @param[in] the_heap is the heap to operate upon 10b5f0: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax <== NOT EXECUTED 10b5f6: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx <== NOT EXECUTED 10b5fd: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10b600: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10b604: 75 1e jne 10b624 <_Thread_Set_state+0x74> <== NOT EXECUTED * to be resized 10b606: 66 a1 b4 ca 11 00 mov 0x11cab4,%ax <== NOT EXECUTED 10b60c: 23 83 98 00 00 00 and 0x98(%ebx),%eax <== NOT EXECUTED 10b612: 66 a3 b4 ca 11 00 mov %ax,0x11cab4 <== NOT EXECUTED 10b618: eb 0a jmp 10b624 <_Thread_Set_state+0x74> <== NOT EXECUTED 10b61a: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10b61c: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10b61f: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10b622: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Priority_Remove_from_bit_map( &the_thread->Priority_map ); } else _Chain_Extract_unprotected( &the_thread->Object.Node ); _ISR_Flash( level ); 10b624: 56 push %esi <== NOT EXECUTED 10b625: 9d popf <== NOT EXECUTED 10b626: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) 10b627: 3b 1d 8c ca 11 00 cmp 0x11ca8c,%ebx <== NOT EXECUTED 10b62d: 75 37 jne 10b666 <_Thread_Set_state+0xb6> <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10b62f: 66 8b 0d b4 ca 11 00 mov 0x11cab4,%cx <== NOT EXECUTED 10b636: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b638: 89 d0 mov %edx,%eax <== NOT EXECUTED 10b63a: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10b63e: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10b641: 66 8b 8c 00 2c cb 11 mov 0x11cb2c(%eax,%eax,1),%cx <== NOT EXECUTED 10b648: 00 <== NOT EXECUTED 10b649: 66 0f bc d1 bsf %cx,%dx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10b64d: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10b650: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10b653: 01 d0 add %edx,%eax <== NOT EXECUTED 10b655: 6b c0 0c imul $0xc,%eax,%eax <== NOT EXECUTED 10b658: 8b 15 c8 c9 11 00 mov 0x11c9c8,%edx <== NOT EXECUTED 10b65e: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10b661: a3 8c ca 11 00 mov %eax,0x11ca8c <== NOT EXECUTED _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) 10b666: 3b 1d c0 ca 11 00 cmp 0x11cac0,%ebx <== NOT EXECUTED 10b66c: 75 07 jne 10b675 <_Thread_Set_state+0xc5> <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10b66e: c6 05 d0 ca 11 00 01 movb $0x1,0x11cad0 <== NOT EXECUTED _ISR_Enable( level ); 10b675: 56 push %esi <== NOT EXECUTED 10b676: 9d popf <== NOT EXECUTED } 10b677: 5b pop %ebx <== NOT EXECUTED 10b678: 5e pop %esi <== NOT EXECUTED 10b679: c9 leave <== NOT EXECUTED 10b67a: c3 ret <== NOT EXECUTED 0010b67c <_Thread_Set_transient>: */ void _Thread_Set_transient( Thread_Control *the_thread ) { 10b67c: 55 push %ebp <== NOT EXECUTED 10b67d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b67f: 56 push %esi <== NOT EXECUTED 10b680: 53 push %ebx <== NOT EXECUTED 10b681: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; uint32_t old_state; Chain_Control *ready; ready = the_thread->ready; 10b684: 8b 8b 8c 00 00 00 mov 0x8c(%ebx),%ecx <== NOT EXECUTED _ISR_Disable( level ); 10b68a: 9c pushf <== NOT EXECUTED 10b68b: fa cli <== NOT EXECUTED 10b68c: 5e pop %esi <== NOT EXECUTED old_state = the_thread->current_state; 10b68d: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED the_thread->current_state = _States_Set( STATES_TRANSIENT, old_state ); 10b690: 89 d0 mov %edx,%eax <== NOT EXECUTED 10b692: 83 c8 04 or $0x4,%eax <== NOT EXECUTED 10b695: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED if ( _States_Is_ready( old_state ) ) { 10b698: 85 d2 test %edx,%edx <== NOT EXECUTED 10b69a: 75 4a jne 10b6e6 <_Thread_Set_transient+0x6a> <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10b69c: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10b69e: 3b 41 08 cmp 0x8(%ecx),%eax <== NOT EXECUTED 10b6a1: 75 39 jne 10b6dc <_Thread_Set_transient+0x60> <== NOT EXECUTED 10b6a3: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10b6a6: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10b6a8: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10b6af: 89 49 08 mov %ecx,0x8(%ecx) <== NOT EXECUTED /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. * * @param[in] the_heap is the heap to operate upon 10b6b2: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax <== NOT EXECUTED 10b6b8: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx <== NOT EXECUTED 10b6bf: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10b6c2: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10b6c6: 75 1e jne 10b6e6 <_Thread_Set_transient+0x6a> <== NOT EXECUTED * to be resized 10b6c8: 66 a1 b4 ca 11 00 mov 0x11cab4,%ax <== NOT EXECUTED 10b6ce: 23 83 98 00 00 00 and 0x98(%ebx),%eax <== NOT EXECUTED 10b6d4: 66 a3 b4 ca 11 00 mov %ax,0x11cab4 <== NOT EXECUTED 10b6da: eb 0a jmp 10b6e6 <_Thread_Set_transient+0x6a> <== NOT EXECUTED 10b6dc: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10b6de: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10b6e1: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10b6e4: 89 10 mov %edx,(%eax) <== NOT EXECUTED } else _Chain_Extract_unprotected( &the_thread->Object.Node ); } _ISR_Enable( level ); 10b6e6: 56 push %esi <== NOT EXECUTED 10b6e7: 9d popf <== NOT EXECUTED } 10b6e8: 5b pop %ebx <== NOT EXECUTED 10b6e9: 5e pop %esi <== NOT EXECUTED 10b6ea: c9 leave <== NOT EXECUTED 10b6eb: c3 ret <== NOT EXECUTED 0010b6ec <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 10b6ec: 55 push %ebp <== NOT EXECUTED 10b6ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b6ef: 53 push %ebx <== NOT EXECUTED 10b6f0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b6f3: a1 80 86 11 00 mov 0x118680,%eax <== NOT EXECUTED 10b6f8: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10b6fb: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10b6fd: 73 02 jae 10b701 <_Thread_Stack_Allocate+0x15> <== NOT EXECUTED 10b6ff: 89 c3 mov %eax,%ebx <== NOT EXECUTED * Call ONLY the CPU table stack allocate hook, _or_ the * the RTEMS workspace allocate. This is so the stack free * routine can call the correct deallocation routine. */ if ( _Configuration_Table->stack_allocate_hook ) { 10b701: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 10b706: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED 10b709: 85 c0 test %eax,%eax <== NOT EXECUTED 10b70b: 74 08 je 10b715 <_Thread_Stack_Allocate+0x29> <== NOT EXECUTED stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size ); 10b70d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b710: 53 push %ebx <== NOT EXECUTED 10b711: ff d0 call *%eax <== NOT EXECUTED 10b713: eb 09 jmp 10b71e <_Thread_Stack_Allocate+0x32> <== NOT EXECUTED * get and keep the stack adjust factor, the stack alignment, and * the context initialization sequence in sync. */ the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); 10b715: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b718: 53 push %ebx <== NOT EXECUTED 10b719: e8 3f 06 00 00 call 10bd5d <_Workspace_Allocate> <== NOT EXECUTED 10b71e: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b720: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } if ( !stack_addr ) 10b723: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b725: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b727: 0f 95 c0 setne %al <== NOT EXECUTED 10b72a: f7 d8 neg %eax <== NOT EXECUTED 10b72c: 21 d8 and %ebx,%eax <== NOT EXECUTED the_stack_size = 0; the_thread->Start.stack = stack_addr; 10b72e: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b731: 89 8a d0 00 00 00 mov %ecx,0xd0(%edx) <== NOT EXECUTED return the_stack_size; } 10b737: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b73a: c9 leave <== NOT EXECUTED 10b73b: c3 ret <== NOT EXECUTED 0010b73c <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 10b73c: 55 push %ebp <== NOT EXECUTED 10b73d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b73f: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED /* * If the API provided the stack space, then don't free it. */ if ( !the_thread->Start.core_allocated_stack ) 10b742: 80 ba c0 00 00 00 00 cmpb $0x0,0xc0(%edx) <== NOT EXECUTED 10b749: 74 21 je 10b76c <_Thread_Stack_Free+0x30> <== NOT EXECUTED * Call ONLY the CPU table stack free hook, or the * the RTEMS workspace free. This is so the free * routine properly matches the allocation of the stack. */ if ( _Configuration_Table->stack_free_hook ) 10b74b: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 10b750: 8b 48 24 mov 0x24(%eax),%ecx <== NOT EXECUTED 10b753: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b755: 8b 82 c8 00 00 00 mov 0xc8(%edx),%eax <== NOT EXECUTED 10b75b: 74 06 je 10b763 <_Thread_Stack_Free+0x27> <== NOT EXECUTED (*_Configuration_Table->stack_free_hook)( 10b75d: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10b760: c9 leave <== NOT EXECUTED * the RTEMS workspace free. This is so the free * routine properly matches the allocation of the stack. */ if ( _Configuration_Table->stack_free_hook ) (*_Configuration_Table->stack_free_hook)( 10b761: ff e1 jmp *%ecx <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); 10b763: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10b766: c9 leave <== NOT EXECUTED if ( _Configuration_Table->stack_free_hook ) (*_Configuration_Table->stack_free_hook)( the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); 10b767: e9 dc 05 00 00 jmp 10bd48 <_Workspace_Free> <== NOT EXECUTED } 10b76c: c9 leave <== NOT EXECUTED 10b76d: c3 ret <== NOT EXECUTED 0010b7c8 <_Thread_Start>: Thread_Start_types the_prototype, void *entry_point, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10b7c8: 55 push %ebp <== NOT EXECUTED 10b7c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b7cb: 53 push %ebx <== NOT EXECUTED 10b7cc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b7cf: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( _States_Is_dormant( the_thread->current_state ) ) { 10b7d2: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b7d4: f6 43 10 01 testb $0x1,0x10(%ebx) <== NOT EXECUTED 10b7d8: 74 42 je 10b81c <_Thread_Start+0x54> <== NOT EXECUTED the_thread->Start.entry_point = (Thread_Entry) entry_point; 10b7da: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b7dd: 89 83 9c 00 00 00 mov %eax,0x9c(%ebx) <== NOT EXECUTED the_thread->Start.prototype = the_prototype; 10b7e3: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b7e6: 89 83 a0 00 00 00 mov %eax,0xa0(%ebx) <== NOT EXECUTED the_thread->Start.pointer_argument = pointer_argument; 10b7ec: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10b7ef: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) <== NOT EXECUTED the_thread->Start.numeric_argument = numeric_argument; 10b7f5: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10b7f8: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) <== NOT EXECUTED _Thread_Load_environment( the_thread ); 10b7fe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b801: 53 push %ebx <== NOT EXECUTED 10b802: e8 99 22 00 00 call 10daa0 <_Thread_Load_environment> <== NOT EXECUTED _Thread_Ready( the_thread ); 10b807: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10b80a: e8 f5 24 00 00 call 10dd04 <_Thread_Ready> <== NOT EXECUTED _User_extensions_Thread_start( the_thread ); 10b80f: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10b812: e8 d9 02 00 00 call 10baf0 <_User_extensions_Thread_start> <== NOT EXECUTED 10b817: b0 01 mov $0x1,%al <== NOT EXECUTED 10b819: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return true; } return false; } 10b81c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b81f: c9 leave <== NOT EXECUTED 10b820: c3 ret <== NOT EXECUTED 0010b770 <_Thread_Start_multitasking>: * ready chain * select heir */ void _Thread_Start_multitasking( void ) { 10b770: 55 push %ebp <== NOT EXECUTED 10b771: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b773: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 10b776: c7 05 a0 cb 11 00 03 movl $0x3,0x11cba0 <== NOT EXECUTED 10b77d: 00 00 00 <== NOT EXECUTED * the system is shut down. */ _System_state_Set( SYSTEM_STATE_UP ); _Context_Switch_necessary = FALSE; 10b780: c6 05 d0 ca 11 00 00 movb $0x0,0x11cad0 <== NOT EXECUTED _Thread_Executing = _Thread_Heir; 10b787: a1 8c ca 11 00 mov 0x11ca8c,%eax <== NOT EXECUTED 10b78c: a3 c0 ca 11 00 mov %eax,0x11cac0 <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) /* * don't need to worry about saving BSP's floating point state */ if ( _Thread_Heir->fp_context != NULL ) 10b791: 83 b8 ec 00 00 00 00 cmpl $0x0,0xec(%eax) <== NOT EXECUTED 10b798: 74 11 je 10b7ab <_Thread_Start_multitasking+0x3b> <== NOT EXECUTED _Context_Restore_fp( &_Thread_Heir->fp_context ); 10b79a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b79d: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10b7a2: 50 push %eax <== NOT EXECUTED 10b7a3: e8 86 06 00 00 call 10be2e <_CPU_Context_restore_fp> <== NOT EXECUTED 10b7a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif _Context_Switch( &_Thread_BSP_context, &_Thread_Heir->Registers ); 10b7ab: 50 push %eax <== NOT EXECUTED 10b7ac: 50 push %eax <== NOT EXECUTED 10b7ad: a1 8c ca 11 00 mov 0x11ca8c,%eax <== NOT EXECUTED 10b7b2: 05 d4 00 00 00 add $0xd4,%eax <== NOT EXECUTED 10b7b7: 50 push %eax <== NOT EXECUTED 10b7b8: 68 e8 c9 11 00 push $0x11c9e8 <== NOT EXECUTED 10b7bd: e8 2e 06 00 00 call 10bdf0 <_CPU_Context_switch> <== NOT EXECUTED 10b7c2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b7c5: c9 leave <== NOT EXECUTED 10b7c6: c3 ret <== NOT EXECUTED 0010cc74 <_Thread_Suspend>: */ void _Thread_Suspend( Thread_Control *the_thread ) { 10cc74: 55 push %ebp <== NOT EXECUTED 10cc75: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cc77: 56 push %esi <== NOT EXECUTED 10cc78: 53 push %ebx <== NOT EXECUTED 10cc79: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; Chain_Control *ready; ready = the_thread->ready; 10cc7c: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx <== NOT EXECUTED _ISR_Disable( level ); 10cc82: 9c pushf <== NOT EXECUTED 10cc83: fa cli <== NOT EXECUTED 10cc84: 5e pop %esi <== NOT EXECUTED the_thread->suspend_count++; 10cc85: ff 43 70 incl 0x70(%ebx) <== NOT EXECUTED if ( !_States_Is_ready( the_thread->current_state ) ) { 10cc88: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10cc8b: 85 c0 test %eax,%eax <== NOT EXECUTED 10cc8d: 74 0d je 10cc9c <_Thread_Suspend+0x28> <== NOT EXECUTED the_thread->current_state = 10cc8f: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 10cc92: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); 10cc95: 56 push %esi <== NOT EXECUTED 10cc96: 9d popf <== NOT EXECUTED 10cc97: e9 a4 00 00 00 jmp 10cd40 <_Thread_Suspend+0xcc> <== NOT EXECUTED return; } the_thread->current_state = STATES_SUSPENDED; 10cc9c: c7 43 10 02 00 00 00 movl $0x2,0x10(%ebx) <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10cca3: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10cca5: 3b 42 08 cmp 0x8(%edx),%eax <== NOT EXECUTED 10cca8: 75 39 jne 10cce3 <_Thread_Suspend+0x6f> <== NOT EXECUTED 10ccaa: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10ccad: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10ccaf: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10ccb6: 89 52 08 mov %edx,0x8(%edx) <== NOT EXECUTED /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. * * @param[in] the_heap is the heap to operate upon 10ccb9: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax <== NOT EXECUTED 10ccbf: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx <== NOT EXECUTED 10ccc6: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10ccc9: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10cccd: 75 1e jne 10cced <_Thread_Suspend+0x79> <== NOT EXECUTED * to be resized 10cccf: 66 a1 70 84 12 00 mov 0x128470,%ax <== NOT EXECUTED 10ccd5: 23 83 98 00 00 00 and 0x98(%ebx),%eax <== NOT EXECUTED 10ccdb: 66 a3 70 84 12 00 mov %ax,0x128470 <== NOT EXECUTED 10cce1: eb 0a jmp 10cced <_Thread_Suspend+0x79> <== NOT EXECUTED 10cce3: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10cce5: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10cce8: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10cceb: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Priority_Remove_from_bit_map( &the_thread->Priority_map ); } else _Chain_Extract_unprotected( &the_thread->Object.Node ); _ISR_Flash( level ); 10cced: 56 push %esi <== NOT EXECUTED 10ccee: 9d popf <== NOT EXECUTED 10ccef: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) 10ccf0: 3b 1d 48 84 12 00 cmp 0x128448,%ebx <== NOT EXECUTED 10ccf6: 75 37 jne 10cd2f <_Thread_Suspend+0xbb> <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10ccf8: 66 8b 0d 70 84 12 00 mov 0x128470,%cx <== NOT EXECUTED 10ccff: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cd01: 89 d0 mov %edx,%eax <== NOT EXECUTED 10cd03: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10cd07: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10cd0a: 66 8b 8c 00 e8 84 12 mov 0x1284e8(%eax,%eax,1),%cx <== NOT EXECUTED 10cd11: 00 <== NOT EXECUTED 10cd12: 66 0f bc d1 bsf %cx,%dx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10cd16: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10cd19: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10cd1c: 01 d0 add %edx,%eax <== NOT EXECUTED 10cd1e: 6b c0 0c imul $0xc,%eax,%eax <== NOT EXECUTED 10cd21: 8b 15 84 83 12 00 mov 0x128384,%edx <== NOT EXECUTED 10cd27: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10cd2a: a3 48 84 12 00 mov %eax,0x128448 <== NOT EXECUTED _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) 10cd2f: 3b 1d 7c 84 12 00 cmp 0x12847c,%ebx <== NOT EXECUTED 10cd35: 75 07 jne 10cd3e <_Thread_Suspend+0xca> <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10cd37: c6 05 8c 84 12 00 01 movb $0x1,0x12848c <== NOT EXECUTED _ISR_Enable( level ); 10cd3e: 56 push %esi <== NOT EXECUTED 10cd3f: 9d popf <== NOT EXECUTED } 10cd40: 5b pop %ebx <== NOT EXECUTED 10cd41: 5e pop %esi <== NOT EXECUTED 10cd42: c9 leave <== NOT EXECUTED 10cd43: c3 ret <== NOT EXECUTED 0010b824 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10b824: 55 push %ebp <== NOT EXECUTED 10b825: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b827: 53 push %ebx <== NOT EXECUTED 10b828: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 10b82b: 8b 1d c0 ca 11 00 mov 0x11cac0,%ebx <== NOT EXECUTED /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10b831: 80 7b 76 00 cmpb $0x0,0x76(%ebx) <== NOT EXECUTED 10b835: 74 4c je 10b883 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED return; if ( !_States_Is_ready( executing->current_state ) ) 10b837: 83 7b 10 00 cmpl $0x0,0x10(%ebx) <== NOT EXECUTED 10b83b: 75 46 jne 10b883 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10b83d: 8b 43 7c mov 0x7c(%ebx),%eax <== NOT EXECUTED 10b840: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10b843: 72 3e jb 10b883 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED 10b845: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b848: 76 07 jbe 10b851 <_Thread_Tickle_timeslice+0x2d> <== NOT EXECUTED 10b84a: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b84d: 75 34 jne 10b883 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED 10b84f: eb 1a jmp 10b86b <_Thread_Tickle_timeslice+0x47> <== NOT EXECUTED case THREAD_CPU_BUDGET_ALGORITHM_NONE: break; case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: if ( (int)(--executing->cpu_time_budget) <= 0 ) { 10b851: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 10b854: 48 dec %eax <== NOT EXECUTED 10b855: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10b858: 85 c0 test %eax,%eax <== NOT EXECUTED 10b85a: 7f 27 jg 10b883 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED _Thread_Reset_timeslice(); 10b85c: e8 43 25 00 00 call 10dda4 <_Thread_Reset_timeslice> <== NOT EXECUTED executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10b861: a1 cc c9 11 00 mov 0x11c9cc,%eax <== NOT EXECUTED 10b866: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10b869: eb 18 jmp 10b883 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED } break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 10b86b: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 10b86e: 48 dec %eax <== NOT EXECUTED 10b86f: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10b872: 85 c0 test %eax,%eax <== NOT EXECUTED 10b874: 75 0d jne 10b883 <_Thread_Tickle_timeslice+0x5f> <== NOT EXECUTED (*executing->budget_callout)( executing ); 10b876: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b879: 53 push %ebx <== NOT EXECUTED 10b87a: ff 93 80 00 00 00 call *0x80(%ebx) <== NOT EXECUTED 10b880: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } } 10b883: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b886: c9 leave <== NOT EXECUTED 10b887: c3 ret <== NOT EXECUTED 0010b888 <_Thread_Yield_processor>: * ready chain * select heir */ void _Thread_Yield_processor( void ) { 10b888: 55 push %ebp <== NOT EXECUTED 10b889: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b88b: 56 push %esi <== NOT EXECUTED 10b88c: 53 push %ebx <== NOT EXECUTED ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10b88d: 8b 0d c0 ca 11 00 mov 0x11cac0,%ecx <== NOT EXECUTED ready = executing->ready; 10b893: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx <== NOT EXECUTED _ISR_Disable( level ); 10b899: 9c pushf <== NOT EXECUTED 10b89a: fa cli <== NOT EXECUTED 10b89b: 5e pop %esi <== NOT EXECUTED if ( !_Chain_Has_only_one_node( ready ) ) { 10b89c: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10b89e: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10b8a1: 74 2e je 10b8d1 <_Thread_Yield_processor+0x49> <== NOT EXECUTED 10b8a3: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10b8a5: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10b8a8: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10b8ab: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10b8ad: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 10b8b0: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10b8b2: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10b8b5: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED 10b8b8: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10b8ba: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 10b8bd: 56 push %esi <== NOT EXECUTED 10b8be: 9d popf <== NOT EXECUTED 10b8bf: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( executing ) ) 10b8c0: 3b 0d 8c ca 11 00 cmp 0x11ca8c,%ecx <== NOT EXECUTED 10b8c6: 75 11 jne 10b8d9 <_Thread_Yield_processor+0x51> <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 10b8c8: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10b8ca: a3 8c ca 11 00 mov %eax,0x11ca8c <== NOT EXECUTED 10b8cf: eb 08 jmp 10b8d9 <_Thread_Yield_processor+0x51> <== NOT EXECUTED _Context_Switch_necessary = TRUE; } else if ( !_Thread_Is_heir( executing ) ) 10b8d1: 3b 0d 8c ca 11 00 cmp 0x11ca8c,%ecx <== NOT EXECUTED 10b8d7: 74 07 je 10b8e0 <_Thread_Yield_processor+0x58> <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10b8d9: c6 05 d0 ca 11 00 01 movb $0x1,0x11cad0 <== NOT EXECUTED _ISR_Enable( level ); 10b8e0: 56 push %esi <== NOT EXECUTED 10b8e1: 9d popf <== NOT EXECUTED } 10b8e2: 5b pop %ebx <== NOT EXECUTED 10b8e3: 5e pop %esi <== NOT EXECUTED 10b8e4: c9 leave <== NOT EXECUTED 10b8e5: c3 ret <== NOT EXECUTED 0010a8d4 <_Thread_blocking_operation_Cancel>: void _Thread_blocking_operation_Cancel( Thread_blocking_operation_States sync_state, Thread_Control *the_thread, ISR_Level level ) { 10a8d4: 55 push %ebp <== NOT EXECUTED 10a8d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a8d7: 53 push %ebx <== NOT EXECUTED 10a8d8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a8db: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10a8de: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED #endif /* * The thread is not waiting on anything after this completes. */ the_thread->Wait.queue = NULL; 10a8e1: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED /* * If the sync state is timed out, this is very likely not needed. * But better safe than sorry when it comes to critical sections. */ if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 10a8e8: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10a8ec: 75 1a jne 10a908 <_Thread_blocking_operation_Cancel+0x34> <== NOT EXECUTED * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 10a8ee: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10a8f5: 50 push %eax <== NOT EXECUTED 10a8f6: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10a8f7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a8fa: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10a8fd: 50 push %eax <== NOT EXECUTED 10a8fe: e8 71 13 00 00 call 10bc74 <_Watchdog_Remove> <== NOT EXECUTED 10a903: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a906: eb 02 jmp 10a90a <_Thread_blocking_operation_Cancel+0x36> <== NOT EXECUTED } else _ISR_Enable( level ); 10a908: 50 push %eax <== NOT EXECUTED 10a909: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10a90a: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 10a911: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10a914: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a917: c9 leave <== NOT EXECUTED 10a918: e9 23 01 00 00 jmp 10aa40 <_Thread_Clear_state> <== NOT EXECUTED 0010b0f8 <_Thread_queue_Dequeue>: */ Thread_Control *_Thread_queue_Dequeue( Thread_queue_Control *the_thread_queue ) { 10b0f8: 55 push %ebp <== NOT EXECUTED 10b0f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b0fb: 53 push %ebx <== NOT EXECUTED 10b0fc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b0ff: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Thread_Control *(*dequeue_p)( Thread_queue_Control * ); Thread_Control *the_thread; ISR_Level level; Thread_blocking_operation_States sync_state; if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 10b102: b8 44 b1 10 00 mov $0x10b144,%eax <== NOT EXECUTED 10b107: 83 7b 34 01 cmpl $0x1,0x34(%ebx) <== NOT EXECUTED 10b10b: 74 05 je 10b112 <_Thread_queue_Dequeue+0x1a> <== NOT EXECUTED 10b10d: b8 28 db 10 00 mov $0x10db28,%eax <== NOT EXECUTED dequeue_p = _Thread_queue_Dequeue_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ dequeue_p = _Thread_queue_Dequeue_fifo; the_thread = (*dequeue_p)( the_thread_queue ); 10b112: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b115: 53 push %ebx <== NOT EXECUTED 10b116: ff d0 call *%eax <== NOT EXECUTED 10b118: 89 c2 mov %eax,%edx <== NOT EXECUTED _ISR_Disable( level ); 10b11a: 9c pushf <== NOT EXECUTED 10b11b: fa cli <== NOT EXECUTED 10b11c: 59 pop %ecx <== NOT EXECUTED if ( !the_thread ) { 10b11d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b120: 85 c0 test %eax,%eax <== NOT EXECUTED 10b122: 75 16 jne 10b13a <_Thread_queue_Dequeue+0x42> <== NOT EXECUTED sync_state = the_thread_queue->sync_state; if ( (sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 10b124: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10b127: 48 dec %eax <== NOT EXECUTED 10b128: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10b12b: 77 0d ja 10b13a <_Thread_queue_Dequeue+0x42> <== NOT EXECUTED (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 10b12d: c7 43 30 03 00 00 00 movl $0x3,0x30(%ebx) <== NOT EXECUTED the_thread = _Thread_Executing; 10b134: 8b 15 c0 ca 11 00 mov 0x11cac0,%edx <== NOT EXECUTED } } _ISR_Enable( level ); 10b13a: 51 push %ecx <== NOT EXECUTED 10b13b: 9d popf <== NOT EXECUTED return the_thread; } 10b13c: 89 d0 mov %edx,%eax <== NOT EXECUTED 10b13e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b141: c9 leave <== NOT EXECUTED 10b142: c3 ret <== NOT EXECUTED 0010db28 <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 10db28: 55 push %ebp <== NOT EXECUTED 10db29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10db2b: 56 push %esi <== NOT EXECUTED 10db2c: 53 push %ebx <== NOT EXECUTED 10db2d: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); 10db30: 9c pushf <== NOT EXECUTED 10db31: fa cli <== NOT EXECUTED 10db32: 5e pop %esi <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10db33: 8b 11 mov (%ecx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 10db35: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10db38: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10db3a: 74 43 je 10db7f <_Thread_queue_Dequeue_fifo+0x57> <== NOT EXECUTED 10db3c: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10db3e: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10db40: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED the_thread = (Thread_Control *) 10db43: 89 d3 mov %edx,%ebx <== NOT EXECUTED _Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo ); the_thread->Wait.queue = NULL; 10db45: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10db4c: 83 7a 50 02 cmpl $0x2,0x50(%edx) <== NOT EXECUTED 10db50: 74 06 je 10db58 <_Thread_queue_Dequeue_fifo+0x30> <== NOT EXECUTED _ISR_Enable( level ); 10db52: 56 push %esi <== NOT EXECUTED 10db53: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10db54: 51 push %ecx <== NOT EXECUTED 10db55: 51 push %ecx <== NOT EXECUTED 10db56: eb 17 jmp 10db6f <_Thread_queue_Dequeue_fifo+0x47> <== NOT EXECUTED * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 10db58: c7 42 50 03 00 00 00 movl $0x3,0x50(%edx) <== NOT EXECUTED _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10db5f: 56 push %esi <== NOT EXECUTED 10db60: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10db61: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10db64: 8d 42 48 lea 0x48(%edx),%eax <== NOT EXECUTED 10db67: 50 push %eax <== NOT EXECUTED 10db68: e8 07 e1 ff ff call 10bc74 <_Watchdog_Remove> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10db6d: 58 pop %eax <== NOT EXECUTED 10db6e: 5a pop %edx <== NOT EXECUTED 10db6f: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10db74: 53 push %ebx <== NOT EXECUTED 10db75: e8 c6 ce ff ff call 10aa40 <_Thread_Clear_state> <== NOT EXECUTED 10db7a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10db7d: eb 04 jmp 10db83 <_Thread_queue_Dequeue_fifo+0x5b> <== NOT EXECUTED #endif return the_thread; } _ISR_Enable( level ); 10db7f: 56 push %esi <== NOT EXECUTED 10db80: 9d popf <== NOT EXECUTED 10db81: 31 db xor %ebx,%ebx <== NOT EXECUTED return NULL; } 10db83: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10db85: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10db88: 5b pop %ebx <== NOT EXECUTED 10db89: 5e pop %esi <== NOT EXECUTED 10db8a: c9 leave <== NOT EXECUTED 10db8b: c3 ret <== NOT EXECUTED 0010b144 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 10b144: 55 push %ebp <== NOT EXECUTED 10b145: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b147: 57 push %edi <== NOT EXECUTED 10b148: 56 push %esi <== NOT EXECUTED 10b149: 53 push %ebx <== NOT EXECUTED 10b14a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b14d: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *new_second_node; Chain_Node *last_node; Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); 10b150: 9c pushf <== NOT EXECUTED 10b151: fa cli <== NOT EXECUTED 10b152: 8f 45 e8 popl -0x18(%ebp) <== NOT EXECUTED 10b155: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b157: 31 c9 xor %ecx,%ecx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10b159: 8b 1c 0e mov (%esi,%ecx,1),%ebx <== NOT EXECUTED for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) { 10b15c: 6b c2 0c imul $0xc,%edx,%eax <== NOT EXECUTED 10b15f: 8d 44 06 04 lea 0x4(%esi,%eax,1),%eax <== NOT EXECUTED 10b163: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10b165: 74 1b je 10b182 <_Thread_queue_Dequeue_priority+0x3e> <== NOT EXECUTED the_thread = (Thread_Control *) 10b167: 89 5d ec mov %ebx,-0x14(%ebp) <== NOT EXECUTED */ _ISR_Enable( level ); return NULL; dequeue: the_thread->Wait.queue = NULL; 10b16a: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED new_first_node = the_thread->Wait.Block2n.first; 10b171: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; 10b174: 8b 33 mov (%ebx),%esi <== NOT EXECUTED previous_node = the_thread->Object.Node.previous; 10b176: 8b 4b 04 mov 0x4(%ebx),%ecx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10b179: 8d 43 3c lea 0x3c(%ebx),%eax <== NOT EXECUTED 10b17c: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10b17e: 75 18 jne 10b198 <_Thread_queue_Dequeue_priority+0x54> <== NOT EXECUTED 10b180: eb 49 jmp 10b1cb <_Thread_queue_Dequeue_priority+0x87> <== NOT EXECUTED Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 10b182: 42 inc %edx <== NOT EXECUTED 10b183: 83 c1 0c add $0xc,%ecx <== NOT EXECUTED Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 10b186: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10b189: 75 ce jne 10b159 <_Thread_queue_Dequeue_priority+0x15> <== NOT EXECUTED } /* * We did not find a thread to unblock. */ _ISR_Enable( level ); 10b18b: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 10b18e: 9d popf <== NOT EXECUTED 10b18f: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) <== NOT EXECUTED 10b196: eb 6d jmp 10b205 <_Thread_queue_Dequeue_priority+0xc1> <== NOT EXECUTED new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; previous_node = the_thread->Object.Node.previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { last_node = the_thread->Wait.Block2n.last; 10b198: 8b 43 40 mov 0x40(%ebx),%eax <== NOT EXECUTED 10b19b: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED new_second_node = new_first_node->next; 10b19e: 8b 3a mov (%edx),%edi <== NOT EXECUTED previous_node->next = new_first_node; 10b1a0: 89 11 mov %edx,(%ecx) <== NOT EXECUTED next_node->previous = new_first_node; 10b1a2: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED new_first_node->next = next_node; 10b1a5: 89 32 mov %esi,(%edx) <== NOT EXECUTED new_first_node->previous = previous_node; 10b1a7: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10b1aa: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10b1ad: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 10b1b0: 74 1e je 10b1d0 <_Thread_queue_Dequeue_priority+0x8c> <== NOT EXECUTED /* > two threads on 2-n */ new_second_node->previous = 10b1b2: 8d 42 38 lea 0x38(%edx),%eax <== NOT EXECUTED 10b1b5: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 10b1b8: 89 7a 38 mov %edi,0x38(%edx) <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 10b1bb: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10b1be: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10b1c1: 8d 42 3c lea 0x3c(%edx),%eax <== NOT EXECUTED 10b1c4: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10b1c7: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10b1c9: eb 05 jmp 10b1d0 <_Thread_queue_Dequeue_priority+0x8c> <== NOT EXECUTED } } else { previous_node->next = next_node; 10b1cb: 89 31 mov %esi,(%ecx) <== NOT EXECUTED next_node->previous = previous_node; 10b1cd: 89 4e 04 mov %ecx,0x4(%esi) <== NOT EXECUTED } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10b1d0: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10b1d4: 74 08 je 10b1de <_Thread_queue_Dequeue_priority+0x9a> <== NOT EXECUTED _ISR_Enable( level ); 10b1d6: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 10b1d9: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10b1da: 51 push %ecx <== NOT EXECUTED 10b1db: 51 push %ecx <== NOT EXECUTED 10b1dc: eb 19 jmp 10b1f7 <_Thread_queue_Dequeue_priority+0xb3> <== NOT EXECUTED * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 10b1de: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10b1e5: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 10b1e8: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10b1e9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b1ec: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10b1ef: 50 push %eax <== NOT EXECUTED 10b1f0: e8 7f 0a 00 00 call 10bc74 <_Watchdog_Remove> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10b1f5: 58 pop %eax <== NOT EXECUTED 10b1f6: 5a pop %edx <== NOT EXECUTED 10b1f7: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10b1fc: 53 push %ebx <== NOT EXECUTED 10b1fd: e8 3e f8 ff ff call 10aa40 <_Thread_Clear_state> <== NOT EXECUTED 10b202: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 10b205: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10b208: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b20b: 5b pop %ebx <== NOT EXECUTED 10b20c: 5e pop %esi <== NOT EXECUTED 10b20d: 5f pop %edi <== NOT EXECUTED 10b20e: c9 leave <== NOT EXECUTED 10b20f: c3 ret <== NOT EXECUTED 0010db8c <_Thread_queue_Enqueue_fifo>: Thread_blocking_operation_States _Thread_queue_Enqueue_fifo ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) { 10db8c: 55 push %ebp <== NOT EXECUTED 10db8d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10db8f: 56 push %esi <== NOT EXECUTED 10db90: 53 push %ebx <== NOT EXECUTED 10db91: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10db94: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED Thread_blocking_operation_States sync_state; ISR_Level level; _ISR_Disable( level ); 10db97: 9c pushf <== NOT EXECUTED 10db98: fa cli <== NOT EXECUTED 10db99: 5b pop %ebx <== NOT EXECUTED sync_state = the_thread_queue->sync_state; 10db9a: 8b 72 30 mov 0x30(%edx),%esi <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10db9d: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) <== NOT EXECUTED if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) { 10dba4: 83 fe 01 cmp $0x1,%esi <== NOT EXECUTED 10dba7: 75 17 jne 10dbc0 <_Thread_queue_Enqueue_fifo+0x34> <== NOT EXECUTED 10dba9: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10dbac: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10dbae: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10dbb1: 89 4a 08 mov %ecx,0x8(%edx) <== NOT EXECUTED 10dbb4: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10dbb6: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED _Chain_Append_unprotected( &the_thread_queue->Queues.Fifo, &the_thread->Object.Node ); the_thread->Wait.queue = the_thread_queue; 10dbb9: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; _ISR_Enable( level ); 10dbbc: 53 push %ebx <== NOT EXECUTED 10dbbd: 9d popf <== NOT EXECUTED 10dbbe: eb 05 jmp 10dbc5 <_Thread_queue_Enqueue_fifo+0x39> <== NOT EXECUTED * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; 10dbc0: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10dbc3: 89 18 mov %ebx,(%eax) <== NOT EXECUTED return sync_state; } 10dbc5: 89 f0 mov %esi,%eax <== NOT EXECUTED 10dbc7: 5b pop %ebx <== NOT EXECUTED 10dbc8: 5e pop %esi <== NOT EXECUTED 10dbc9: c9 leave <== NOT EXECUTED 10dbca: c3 ret <== NOT EXECUTED 0010b29c <_Thread_queue_Enqueue_priority>: Thread_blocking_operation_States _Thread_queue_Enqueue_priority ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) { 10b29c: 55 push %ebp <== NOT EXECUTED 10b29d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b29f: 57 push %edi <== NOT EXECUTED 10b2a0: 56 push %esi <== NOT EXECUTED 10b2a1: 53 push %ebx <== NOT EXECUTED 10b2a2: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10b2a5: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10b2a8: 8d 41 3c lea 0x3c(%ecx),%eax <== NOT EXECUTED 10b2ab: 89 41 38 mov %eax,0x38(%ecx) <== NOT EXECUTED 10b2ae: c7 41 3c 00 00 00 00 movl $0x0,0x3c(%ecx) <== NOT EXECUTED 10b2b5: 8d 41 38 lea 0x38(%ecx),%eax <== NOT EXECUTED 10b2b8: 89 41 40 mov %eax,0x40(%ecx) <== NOT EXECUTED Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 10b2bb: 8b 79 14 mov 0x14(%ecx),%edi <== NOT EXECUTED extern "C" { #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. 10b2be: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b2c0: c1 e8 06 shr $0x6,%eax <== NOT EXECUTED header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 10b2c3: 6b c0 0c imul $0xc,%eax,%eax <== NOT EXECUTED 10b2c6: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b2c9: 01 c3 add %eax,%ebx <== NOT EXECUTED block_state = the_thread_queue->state; 10b2cb: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b2ce: 8b 52 38 mov 0x38(%edx),%edx <== NOT EXECUTED 10b2d1: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED if ( _Thread_queue_Is_reverse_search( priority ) ) 10b2d4: f7 c7 20 00 00 00 test $0x20,%edi <== NOT EXECUTED 10b2da: 75 77 jne 10b353 <_Thread_queue_Enqueue_priority+0xb7> <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10b2dc: 83 c3 04 add $0x4,%ebx <== NOT EXECUTED 10b2df: 89 5d ec mov %ebx,-0x14(%ebp) <== NOT EXECUTED goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; 10b2e2: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 10b2e5: 9c pushf <== NOT EXECUTED 10b2e6: fa cli <== NOT EXECUTED 10b2e7: 5e pop %esi <== NOT EXECUTED search_thread = (Thread_Control *) header->first; 10b2e8: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 10b2eb: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b2ee: 8b 14 18 mov (%eax,%ebx,1),%edx <== NOT EXECUTED 10b2f1: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp) <== NOT EXECUTED 10b2f8: eb 1b jmp 10b315 <_Thread_queue_Enqueue_priority+0x79> <== NOT EXECUTED while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { search_priority = search_thread->current_priority; 10b2fa: 8b 5a 14 mov 0x14(%edx),%ebx <== NOT EXECUTED 10b2fd: 89 5d e0 mov %ebx,-0x20(%ebp) <== NOT EXECUTED if ( priority <= search_priority ) 10b300: 39 df cmp %ebx,%edi <== NOT EXECUTED 10b302: 76 16 jbe 10b31a <_Thread_queue_Enqueue_priority+0x7e> <== NOT EXECUTED break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10b304: 56 push %esi <== NOT EXECUTED 10b305: 9d popf <== NOT EXECUTED 10b306: fa cli <== NOT EXECUTED if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10b307: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10b30a: 85 42 10 test %eax,0x10(%edx) <== NOT EXECUTED 10b30d: 75 04 jne 10b313 <_Thread_queue_Enqueue_priority+0x77> <== NOT EXECUTED _ISR_Enable( level ); 10b30f: 56 push %esi <== NOT EXECUTED 10b310: 9d popf <== NOT EXECUTED 10b311: eb d2 jmp 10b2e5 <_Thread_queue_Enqueue_priority+0x49> <== NOT EXECUTED goto restart_forward_search; } search_thread = 10b313: 8b 12 mov (%edx),%edx <== NOT EXECUTED restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10b315: 3b 55 ec cmp -0x14(%ebp),%edx <== NOT EXECUTED 10b318: 75 e0 jne 10b2fa <_Thread_queue_Enqueue_priority+0x5e> <== NOT EXECUTED 10b31a: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 10b31d: 89 f3 mov %esi,%ebx <== NOT EXECUTED } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10b31f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b322: 83 78 30 01 cmpl $0x1,0x30(%eax) <== NOT EXECUTED 10b326: 0f 85 b4 00 00 00 jne 10b3e0 <_Thread_queue_Enqueue_priority+0x144> <== NOT EXECUTED THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10b32c: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) <== NOT EXECUTED if ( priority == search_priority ) 10b333: 3b 7d e0 cmp -0x20(%ebp),%edi <== NOT EXECUTED 10b336: 0f 84 87 00 00 00 je 10b3c3 <_Thread_queue_Enqueue_priority+0x127> <== NOT EXECUTED goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10b33c: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10b33f: 89 11 mov %edx,(%ecx) <== NOT EXECUTED the_node->previous = previous_node; 10b341: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED previous_node->next = the_node; 10b344: 89 08 mov %ecx,(%eax) <== NOT EXECUTED search_node->previous = the_node; 10b346: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10b349: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b34c: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10b34f: 56 push %esi <== NOT EXECUTED 10b350: 9d popf <== NOT EXECUTED 10b351: eb 69 jmp 10b3bc <_Thread_queue_Enqueue_priority+0x120> <== NOT EXECUTED restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; 10b353: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10b356: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 10b359: 0f b6 05 84 86 11 00 movzbl 0x118684,%eax <== NOT EXECUTED 10b360: 40 inc %eax <== NOT EXECUTED 10b361: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED _ISR_Disable( level ); 10b364: 9c pushf <== NOT EXECUTED 10b365: fa cli <== NOT EXECUTED 10b366: 5e pop %esi <== NOT EXECUTED search_thread = (Thread_Control *) header->last; 10b367: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10b36a: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10b36c: eb 1c jmp 10b38a <_Thread_queue_Enqueue_priority+0xee> <== NOT EXECUTED while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { search_priority = search_thread->current_priority; 10b36e: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED 10b371: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED if ( priority >= search_priority ) 10b374: 39 c7 cmp %eax,%edi <== NOT EXECUTED 10b376: 73 16 jae 10b38e <_Thread_queue_Enqueue_priority+0xf2> <== NOT EXECUTED break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 10b378: 56 push %esi <== NOT EXECUTED 10b379: 9d popf <== NOT EXECUTED 10b37a: fa cli <== NOT EXECUTED if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10b37b: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10b37e: 85 42 10 test %eax,0x10(%edx) <== NOT EXECUTED 10b381: 75 04 jne 10b387 <_Thread_queue_Enqueue_priority+0xeb> <== NOT EXECUTED _ISR_Enable( level ); 10b383: 56 push %esi <== NOT EXECUTED 10b384: 9d popf <== NOT EXECUTED 10b385: eb d2 jmp 10b359 <_Thread_queue_Enqueue_priority+0xbd> <== NOT EXECUTED goto restart_reverse_search; } search_thread = (Thread_Control *) 10b387: 8b 52 04 mov 0x4(%edx),%edx <== NOT EXECUTED restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10b38a: 39 da cmp %ebx,%edx <== NOT EXECUTED 10b38c: 75 e0 jne 10b36e <_Thread_queue_Enqueue_priority+0xd2> <== NOT EXECUTED 10b38e: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 10b391: 89 f3 mov %esi,%ebx <== NOT EXECUTED } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10b393: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b396: 83 78 30 01 cmpl $0x1,0x30(%eax) <== NOT EXECUTED 10b39a: 75 44 jne 10b3e0 <_Thread_queue_Enqueue_priority+0x144> <== NOT EXECUTED THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10b39c: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) <== NOT EXECUTED if ( priority == search_priority ) 10b3a3: 3b 7d e0 cmp -0x20(%ebp),%edi <== NOT EXECUTED 10b3a6: 74 1b je 10b3c3 <_Thread_queue_Enqueue_priority+0x127> <== NOT EXECUTED goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10b3a8: 8b 02 mov (%edx),%eax <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10b3aa: 89 01 mov %eax,(%ecx) <== NOT EXECUTED the_node->previous = search_node; 10b3ac: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED search_node->next = the_node; 10b3af: 89 0a mov %ecx,(%edx) <== NOT EXECUTED next_node->previous = the_node; 10b3b1: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10b3b4: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b3b7: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10b3ba: 56 push %esi <== NOT EXECUTED 10b3bb: 9d popf <== NOT EXECUTED 10b3bc: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10b3c1: eb 28 jmp 10b3eb <_Thread_queue_Enqueue_priority+0x14f> <== NOT EXECUTED 10b3c3: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10b3c6: 83 c0 3c add $0x3c,%eax <== NOT EXECUTED return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 10b3c9: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10b3cc: 89 01 mov %eax,(%ecx) <== NOT EXECUTED the_node->previous = previous_node; 10b3ce: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED previous_node->next = the_node; 10b3d1: 89 0a mov %ecx,(%edx) <== NOT EXECUTED search_node->previous = the_node; 10b3d3: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10b3d6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b3d9: 89 41 44 mov %eax,0x44(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10b3dc: 53 push %ebx <== NOT EXECUTED 10b3dd: 9d popf <== NOT EXECUTED 10b3de: eb dc jmp 10b3bc <_Thread_queue_Enqueue_priority+0x120> <== NOT EXECUTED * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; 10b3e0: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b3e3: 89 18 mov %ebx,(%eax) <== NOT EXECUTED return the_thread_queue->sync_state; 10b3e5: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b3e8: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED } 10b3eb: 83 c4 18 add $0x18,%esp <== NOT EXECUTED 10b3ee: 5b pop %ebx <== NOT EXECUTED 10b3ef: 5e pop %esi <== NOT EXECUTED 10b3f0: 5f pop %edi <== NOT EXECUTED 10b3f1: c9 leave <== NOT EXECUTED 10b3f2: c3 ret <== NOT EXECUTED 0010b210 <_Thread_queue_Enqueue_with_handler>: void _Thread_queue_Enqueue_with_handler( Thread_queue_Control *the_thread_queue, Watchdog_Interval timeout, Thread_queue_Timeout_callout handler ) { 10b210: 55 push %ebp <== NOT EXECUTED 10b211: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b213: 57 push %edi <== NOT EXECUTED 10b214: 56 push %esi <== NOT EXECUTED 10b215: 53 push %ebx <== NOT EXECUTED 10b216: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 10b219: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10b21c: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Thread_queue_Control *, Thread_Control *, ISR_Level * ); the_thread = _Thread_Executing; 10b21f: 8b 1d c0 ca 11 00 mov 0x11cac0,%ebx <== NOT EXECUTED else #endif /* * Set the blocking state for this thread queue in the thread. */ _Thread_Set_state( the_thread, the_thread_queue->state ); 10b225: ff 76 38 pushl 0x38(%esi) <== NOT EXECUTED 10b228: 53 push %ebx <== NOT EXECUTED 10b229: e8 82 03 00 00 call 10b5b0 <_Thread_Set_state> <== NOT EXECUTED /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { 10b22e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b231: 85 ff test %edi,%edi <== NOT EXECUTED 10b233: 74 30 je 10b265 <_Thread_queue_Enqueue_with_handler+0x55> <== NOT EXECUTED _Watchdog_Initialize( 10b235: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10b238: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10b23f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10b242: 89 53 64 mov %edx,0x64(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10b245: 89 43 68 mov %eax,0x68(%ebx) <== NOT EXECUTED * the heap 10b248: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10b24f: 89 7b 54 mov %edi,0x54(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10b252: 57 push %edi <== NOT EXECUTED 10b253: 57 push %edi <== NOT EXECUTED 10b254: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10b257: 50 push %eax <== NOT EXECUTED 10b258: 68 e0 ca 11 00 push $0x11cae0 <== NOT EXECUTED 10b25d: e8 fa 08 00 00 call 10bb5c <_Watchdog_Insert> <== NOT EXECUTED 10b262: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * Now enqueue the thread per the discipline for this thread queue. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 10b265: ba 9c b2 10 00 mov $0x10b29c,%edx <== NOT EXECUTED 10b26a: 83 7e 34 01 cmpl $0x1,0x34(%esi) <== NOT EXECUTED 10b26e: 74 05 je 10b275 <_Thread_queue_Enqueue_with_handler+0x65> <== NOT EXECUTED 10b270: ba 8c db 10 00 mov $0x10db8c,%edx <== NOT EXECUTED enqueue_p = _Thread_queue_Enqueue_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ enqueue_p = _Thread_queue_Enqueue_fifo; sync_state = (*enqueue_p)( the_thread_queue, the_thread, &level ); 10b275: 51 push %ecx <== NOT EXECUTED 10b276: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b279: 50 push %eax <== NOT EXECUTED 10b27a: 53 push %ebx <== NOT EXECUTED 10b27b: 56 push %esi <== NOT EXECUTED 10b27c: ff d2 call *%edx <== NOT EXECUTED if ( sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 10b27e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b281: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10b284: 74 0e je 10b294 <_Thread_queue_Enqueue_with_handler+0x84> <== NOT EXECUTED _Thread_blocking_operation_Cancel( sync_state, the_thread, level ); 10b286: 52 push %edx <== NOT EXECUTED 10b287: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10b28a: 53 push %ebx <== NOT EXECUTED 10b28b: 50 push %eax <== NOT EXECUTED 10b28c: e8 43 f6 ff ff call 10a8d4 <_Thread_blocking_operation_Cancel> <== NOT EXECUTED 10b291: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b294: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b297: 5b pop %ebx <== NOT EXECUTED 10b298: 5e pop %esi <== NOT EXECUTED 10b299: 5f pop %edi <== NOT EXECUTED 10b29a: c9 leave <== NOT EXECUTED 10b29b: c3 ret <== NOT EXECUTED 0010dbcc <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10dbcc: 55 push %ebp <== NOT EXECUTED 10dbcd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dbcf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dbd2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10dbd5: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED /* * Can not use indirect function pointer here since Extract priority * is a macro and the underlying methods do not have the same signature. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 10dbd8: 83 78 34 01 cmpl $0x1,0x34(%eax) <== NOT EXECUTED 10dbdc: 75 0f jne 10dbed <_Thread_queue_Extract+0x21> <== NOT EXECUTED _Thread_queue_Extract_priority( the_thread_queue, the_thread ); 10dbde: 51 push %ecx <== NOT EXECUTED 10dbdf: 6a 00 push $0x0 <== NOT EXECUTED 10dbe1: 52 push %edx <== NOT EXECUTED 10dbe2: 50 push %eax <== NOT EXECUTED 10dbe3: e8 14 00 00 00 call 10dbfc <_Thread_queue_Extract_priority_helper> <== NOT EXECUTED 10dbe8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); } 10dbeb: c9 leave <== NOT EXECUTED 10dbec: c3 ret <== NOT EXECUTED * is a macro and the underlying methods do not have the same signature. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) _Thread_queue_Extract_priority( the_thread_queue, the_thread ); else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 10dbed: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 10dbf0: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10dbf3: c9 leave <== NOT EXECUTED * is a macro and the underlying methods do not have the same signature. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) _Thread_queue_Extract_priority( the_thread_queue, the_thread ); else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 10dbf4: e9 f3 09 00 00 jmp 10e5ec <_Thread_queue_Extract_fifo> <== NOT EXECUTED 0010e5ec <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10e5ec: 55 push %ebp <== NOT EXECUTED 10e5ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e5ef: 53 push %ebx <== NOT EXECUTED 10e5f0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10e5f3: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10e5f6: 9c pushf <== NOT EXECUTED 10e5f7: fa cli <== NOT EXECUTED 10e5f8: 59 pop %ecx <== NOT EXECUTED if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10e5f9: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) <== NOT EXECUTED 10e600: 75 07 jne 10e609 <_Thread_queue_Extract_fifo+0x1d> <== NOT EXECUTED _ISR_Enable( level ); 10e602: 51 push %ecx <== NOT EXECUTED 10e603: 9d popf <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10e604: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e607: c9 leave <== NOT EXECUTED 10e608: c3 ret <== NOT EXECUTED 10e609: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10e60b: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10e60e: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10e611: 89 10 mov %edx,(%eax) <== NOT EXECUTED return; } _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; 10e613: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10e61a: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10e61e: 74 04 je 10e624 <_Thread_queue_Extract_fifo+0x38> <== NOT EXECUTED _ISR_Enable( level ); 10e620: 51 push %ecx <== NOT EXECUTED 10e621: 9d popf <== NOT EXECUTED 10e622: eb 18 jmp 10e63c <_Thread_queue_Extract_fifo+0x50> <== NOT EXECUTED * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 10e624: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10e62b: 51 push %ecx <== NOT EXECUTED 10e62c: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10e62d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e630: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10e633: 50 push %eax <== NOT EXECUTED 10e634: e8 3b d6 ff ff call 10bc74 <_Watchdog_Remove> <== NOT EXECUTED 10e639: 83 c4 10 add $0x10,%esp <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10e63c: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 10e643: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10e646: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e649: c9 leave <== NOT EXECUTED 10e64a: e9 f1 c3 ff ff jmp 10aa40 <_Thread_Clear_state> <== NOT EXECUTED 0010dbfc <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, bool requeuing ) { 10dbfc: 55 push %ebp <== NOT EXECUTED 10dbfd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dbff: 57 push %edi <== NOT EXECUTED 10dc00: 56 push %esi <== NOT EXECUTED 10dc01: 53 push %ebx <== NOT EXECUTED 10dc02: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10dc05: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10dc08: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 10dc0b: 88 45 eb mov %al,-0x15(%ebp) <== NOT EXECUTED Chain_Node *new_first_node; Chain_Node *new_second_node; Chain_Node *last_node; the_node = (Chain_Node *) the_thread; _ISR_Disable( level ); 10dc0e: 9c pushf <== NOT EXECUTED 10dc0f: fa cli <== NOT EXECUTED 10dc10: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10dc13: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) <== NOT EXECUTED 10dc1a: 75 09 jne 10dc25 <_Thread_queue_Extract_priority_helper+0x29> <== NOT EXECUTED _ISR_Enable( level ); 10dc1c: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10dc1f: 9d popf <== NOT EXECUTED 10dc20: e9 8f 00 00 00 jmp 10dcb4 <_Thread_queue_Extract_priority_helper+0xb8> <== NOT EXECUTED /* * The thread was actually waiting on a thread queue so let's remove it. */ next_node = the_node->next; 10dc25: 8b 33 mov (%ebx),%esi <== NOT EXECUTED previous_node = the_node->previous; 10dc27: 8b 4b 04 mov 0x4(%ebx),%ecx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10dc2a: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10dc2d: 8d 43 3c lea 0x3c(%ebx),%eax <== NOT EXECUTED 10dc30: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10dc32: 74 33 je 10dc67 <_Thread_queue_Extract_priority_helper+0x6b> <== NOT EXECUTED new_first_node = the_thread->Wait.Block2n.first; new_first_thread = (Thread_Control *) new_first_node; last_node = the_thread->Wait.Block2n.last; 10dc34: 8b 43 40 mov 0x40(%ebx),%eax <== NOT EXECUTED 10dc37: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED new_second_node = new_first_node->next; 10dc3a: 8b 3a mov (%edx),%edi <== NOT EXECUTED previous_node->next = new_first_node; 10dc3c: 89 11 mov %edx,(%ecx) <== NOT EXECUTED next_node->previous = new_first_node; 10dc3e: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED new_first_node->next = next_node; 10dc41: 89 32 mov %esi,(%edx) <== NOT EXECUTED new_first_node->previous = previous_node; 10dc43: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10dc46: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10dc49: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 10dc4c: 74 1e je 10dc6c <_Thread_queue_Extract_priority_helper+0x70> <== NOT EXECUTED /* > two threads on 2-n */ new_second_node->previous = 10dc4e: 8d 42 38 lea 0x38(%edx),%eax <== NOT EXECUTED 10dc51: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 10dc54: 89 7a 38 mov %edi,0x38(%edx) <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 10dc57: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10dc5a: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10dc5d: 8d 42 3c lea 0x3c(%edx),%eax <== NOT EXECUTED 10dc60: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10dc63: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10dc65: eb 05 jmp 10dc6c <_Thread_queue_Extract_priority_helper+0x70> <== NOT EXECUTED } } else { previous_node->next = next_node; 10dc67: 89 31 mov %esi,(%ecx) <== NOT EXECUTED next_node->previous = previous_node; 10dc69: 89 4e 04 mov %ecx,0x4(%esi) <== NOT EXECUTED /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 10dc6c: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) <== NOT EXECUTED 10dc70: 74 06 je 10dc78 <_Thread_queue_Extract_priority_helper+0x7c> <== NOT EXECUTED _ISR_Enable( level ); 10dc72: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10dc75: 9d popf <== NOT EXECUTED 10dc76: eb 3c jmp 10dcb4 <_Thread_queue_Extract_priority_helper+0xb8> <== NOT EXECUTED return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10dc78: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10dc7c: 74 06 je 10dc84 <_Thread_queue_Extract_priority_helper+0x88> <== NOT EXECUTED _ISR_Enable( level ); 10dc7e: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10dc81: 9d popf <== NOT EXECUTED 10dc82: eb 1a jmp 10dc9e <_Thread_queue_Extract_priority_helper+0xa2> <== NOT EXECUTED * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 10dc84: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10dc8b: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10dc8e: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10dc8f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10dc92: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10dc95: 50 push %eax <== NOT EXECUTED 10dc96: e8 d9 df ff ff call 10bc74 <_Watchdog_Remove> <== NOT EXECUTED 10dc9b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10dc9e: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 10dca5: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10dca8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dcab: 5b pop %ebx <== NOT EXECUTED 10dcac: 5e pop %esi <== NOT EXECUTED 10dcad: 5f pop %edi <== NOT EXECUTED 10dcae: c9 leave <== NOT EXECUTED 10dcaf: e9 8c cd ff ff jmp 10aa40 <_Thread_Clear_state> <== NOT EXECUTED 10dcb4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dcb7: 5b pop %ebx <== NOT EXECUTED 10dcb8: 5e pop %esi <== NOT EXECUTED 10dcb9: 5f pop %edi <== NOT EXECUTED 10dcba: c9 leave <== NOT EXECUTED 10dcbb: c3 ret <== NOT EXECUTED 0010b3f4 <_Thread_queue_Extract_with_proxy>: */ bool _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 10b3f4: 55 push %ebp <== NOT EXECUTED 10b3f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b3f7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b3fa: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED States_Control state; state = the_thread->current_state; if ( _States_Is_waiting_on_thread_queue( state ) ) { 10b3fd: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b3ff: f7 42 10 e0 be 03 00 testl $0x3bee0,0x10(%edx) <== NOT EXECUTED 10b406: 74 10 je 10b418 <_Thread_queue_Extract_with_proxy+0x24> <== NOT EXECUTED if ( proxy_extract_callout ) (*proxy_extract_callout)( the_thread ); } #endif _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10b408: 50 push %eax <== NOT EXECUTED 10b409: 50 push %eax <== NOT EXECUTED 10b40a: 52 push %edx <== NOT EXECUTED 10b40b: ff 72 44 pushl 0x44(%edx) <== NOT EXECUTED 10b40e: e8 b9 27 00 00 call 10dbcc <_Thread_queue_Extract> <== NOT EXECUTED 10b413: b0 01 mov $0x1,%al <== NOT EXECUTED 10b415: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return TRUE; } return FALSE; } 10b418: c9 leave <== NOT EXECUTED 10b419: c3 ret <== NOT EXECUTED 00118790 <_Thread_queue_First>: */ Thread_Control *_Thread_queue_First( Thread_queue_Control *the_thread_queue ) { 118790: 55 push %ebp <== NOT EXECUTED 118791: 89 e5 mov %esp,%ebp <== NOT EXECUTED 118793: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED Thread_Control * (*first_p)(Thread_queue_Control *); if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 118796: b9 ac 87 11 00 mov $0x1187ac,%ecx <== NOT EXECUTED 11879b: 83 78 34 01 cmpl $0x1,0x34(%eax) <== NOT EXECUTED 11879f: 74 05 je 1187a6 <_Thread_queue_First+0x16> <== NOT EXECUTED 1187a1: b9 c8 90 11 00 mov $0x1190c8,%ecx <== NOT EXECUTED first_p = _Thread_queue_First_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; return (*first_p)( the_thread_queue ); 1187a6: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 1187a9: c9 leave <== NOT EXECUTED if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) first_p = _Thread_queue_First_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; return (*first_p)( the_thread_queue ); 1187aa: ff e1 jmp *%ecx <== NOT EXECUTED 001190c8 <_Thread_queue_First_fifo>: */ Thread_Control *_Thread_queue_First_fifo( Thread_queue_Control *the_thread_queue ) { 1190c8: 55 push %ebp <== NOT EXECUTED 1190c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1190cb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) 1190ce: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED return (Thread_Control *) the_thread_queue->Queues.Fifo.first; 1190d1: 8b 00 mov (%eax),%eax <== NOT EXECUTED Thread_Control *_Thread_queue_First_fifo( Thread_queue_Control *the_thread_queue ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) 1190d3: 39 d0 cmp %edx,%eax <== NOT EXECUTED 1190d5: 0f 95 c2 setne %dl <== NOT EXECUTED 1190d8: 0f b6 d2 movzbl %dl,%edx <== NOT EXECUTED 1190db: f7 da neg %edx <== NOT EXECUTED 1190dd: 21 d0 and %edx,%eax <== NOT EXECUTED return (Thread_Control *) the_thread_queue->Queues.Fifo.first; return NULL; } 1190df: c9 leave <== NOT EXECUTED 1190e0: c3 ret <== NOT EXECUTED 001187ac <_Thread_queue_First_priority>: */ Thread_Control *_Thread_queue_First_priority ( Thread_queue_Control *the_thread_queue ) { 1187ac: 55 push %ebp <== NOT EXECUTED 1187ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1187af: 56 push %esi <== NOT EXECUTED 1187b0: 53 push %ebx <== NOT EXECUTED 1187b1: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 1187b4: 31 d2 xor %edx,%edx <== NOT EXECUTED 1187b6: 31 c9 xor %ecx,%ecx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 1187b8: 8b 1c 0e mov (%esi,%ecx,1),%ebx <== NOT EXECUTED uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) 1187bb: 6b c2 0c imul $0xc,%edx,%eax <== NOT EXECUTED 1187be: 8d 44 06 04 lea 0x4(%esi,%eax,1),%eax <== NOT EXECUTED 1187c2: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 1187c4: 74 04 je 1187ca <_Thread_queue_First_priority+0x1e> <== NOT EXECUTED return (Thread_Control *) 1187c6: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1187c8: eb 0b jmp 1187d5 <_Thread_queue_First_priority+0x29> <== NOT EXECUTED { uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 1187ca: 42 inc %edx <== NOT EXECUTED 1187cb: 83 c1 0c add $0xc,%ecx <== NOT EXECUTED ) { uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 1187ce: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 1187d1: 75 e5 jne 1187b8 <_Thread_queue_First_priority+0xc> <== NOT EXECUTED 1187d3: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) return (Thread_Control *) the_thread_queue->Queues.Priority[ index ].first; } return NULL; } 1187d5: 5b pop %ebx <== NOT EXECUTED 1187d6: 5e pop %esi <== NOT EXECUTED 1187d7: c9 leave <== NOT EXECUTED 1187d8: c3 ret <== NOT EXECUTED 0010b41c <_Thread_queue_Flush>: void _Thread_queue_Flush( Thread_queue_Control *the_thread_queue, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 10b41c: 55 push %ebp <== NOT EXECUTED 10b41d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b41f: 56 push %esi <== NOT EXECUTED 10b420: 53 push %ebx <== NOT EXECUTED 10b421: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10b424: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10b427: eb 03 jmp 10b42c <_Thread_queue_Flush+0x10> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) ( *remote_extract_callout )( the_thread ); else #endif the_thread->Wait.return_code = status; 10b429: 89 58 34 mov %ebx,0x34(%eax) <== NOT EXECUTED uint32_t status ) { Thread_Control *the_thread; while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) { 10b42c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b42f: 56 push %esi <== NOT EXECUTED 10b430: e8 c3 fc ff ff call 10b0f8 <_Thread_queue_Dequeue> <== NOT EXECUTED 10b435: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b438: 85 c0 test %eax,%eax <== NOT EXECUTED 10b43a: 75 ed jne 10b429 <_Thread_queue_Flush+0xd> <== NOT EXECUTED ( *remote_extract_callout )( the_thread ); else #endif the_thread->Wait.return_code = status; } } 10b43c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b43f: 5b pop %ebx <== NOT EXECUTED 10b440: 5e pop %esi <== NOT EXECUTED 10b441: c9 leave <== NOT EXECUTED 10b442: c3 ret <== NOT EXECUTED 0010b444 <_Thread_queue_Initialize>: Thread_queue_Control *the_thread_queue, Thread_queue_Disciplines the_discipline, States_Control state, uint32_t timeout_status ) { 10b444: 55 push %ebp <== NOT EXECUTED 10b445: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b447: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b44a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED the_thread_queue->state = state; 10b44d: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10b450: 89 51 38 mov %edx,0x38(%ecx) <== NOT EXECUTED the_thread_queue->discipline = the_discipline; 10b453: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED the_thread_queue->timeout_status = timeout_status; 10b456: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10b459: 89 51 3c mov %edx,0x3c(%ecx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10b45c: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) <== NOT EXECUTED if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10b463: 48 dec %eax <== NOT EXECUTED 10b464: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10b467: 75 47 jne 10b4b0 <_Thread_queue_Initialize+0x6c> <== NOT EXECUTED 10b469: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10b46b: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10b472: 89 49 08 mov %ecx,0x8(%ecx) <== NOT EXECUTED 10b475: 8d 41 10 lea 0x10(%ecx),%eax <== NOT EXECUTED 10b478: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED 10b47b: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx) <== NOT EXECUTED 10b482: 8d 41 0c lea 0xc(%ecx),%eax <== NOT EXECUTED 10b485: 89 41 14 mov %eax,0x14(%ecx) <== NOT EXECUTED 10b488: 8d 41 1c lea 0x1c(%ecx),%eax <== NOT EXECUTED 10b48b: 89 41 18 mov %eax,0x18(%ecx) <== NOT EXECUTED 10b48e: c7 41 1c 00 00 00 00 movl $0x0,0x1c(%ecx) <== NOT EXECUTED 10b495: 8d 41 18 lea 0x18(%ecx),%eax <== NOT EXECUTED 10b498: 89 41 20 mov %eax,0x20(%ecx) <== NOT EXECUTED 10b49b: 8d 41 28 lea 0x28(%ecx),%eax <== NOT EXECUTED 10b49e: 89 41 24 mov %eax,0x24(%ecx) <== NOT EXECUTED 10b4a1: c7 41 28 00 00 00 00 movl $0x0,0x28(%ecx) <== NOT EXECUTED 10b4a8: 8d 41 24 lea 0x24(%ecx),%eax <== NOT EXECUTED 10b4ab: 89 41 2c mov %eax,0x2c(%ecx) <== NOT EXECUTED 10b4ae: eb 0c jmp 10b4bc <_Thread_queue_Initialize+0x78> <== NOT EXECUTED 10b4b0: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10b4b2: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10b4b9: 89 49 08 mov %ecx,0x8(%ecx) <== NOT EXECUTED _Chain_Initialize_empty( &the_thread_queue->Queues.Priority[index] ); } else { /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Chain_Initialize_empty( &the_thread_queue->Queues.Fifo ); } } 10b4bc: c9 leave <== NOT EXECUTED 10b4bd: c3 ret <== NOT EXECUTED 0010dcbc <_Thread_queue_Process_timeout>: #include void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { 10dcbc: 55 push %ebp <== NOT EXECUTED 10dcbd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dcbf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dcc2: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 10dcc5: 8b 51 44 mov 0x44(%ecx),%edx <== NOT EXECUTED * 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 && 10dcc8: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10dccb: 85 c0 test %eax,%eax <== NOT EXECUTED 10dccd: 74 1c je 10dceb <_Thread_queue_Process_timeout+0x2f> <== NOT EXECUTED 10dccf: 3b 0d c0 ca 11 00 cmp 0x11cac0,%ecx <== NOT EXECUTED 10dcd5: 75 14 jne 10dceb <_Thread_queue_Process_timeout+0x2f> <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) { 10dcd7: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10dcda: 74 23 je 10dcff <_Thread_queue_Process_timeout+0x43> <== NOT EXECUTED the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10dcdc: 8b 42 3c mov 0x3c(%edx),%eax <== NOT EXECUTED 10dcdf: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10dce2: c7 42 30 02 00 00 00 movl $0x2,0x30(%edx) <== NOT EXECUTED 10dce9: eb 14 jmp 10dcff <_Thread_queue_Process_timeout+0x43> <== NOT EXECUTED } } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10dceb: 8b 42 3c mov 0x3c(%edx),%eax <== NOT EXECUTED 10dcee: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10dcf1: 50 push %eax <== NOT EXECUTED 10dcf2: 50 push %eax <== NOT EXECUTED 10dcf3: 51 push %ecx <== NOT EXECUTED 10dcf4: ff 71 44 pushl 0x44(%ecx) <== NOT EXECUTED 10dcf7: e8 d0 fe ff ff call 10dbcc <_Thread_queue_Extract> <== NOT EXECUTED 10dcfc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 10dcff: c9 leave <== NOT EXECUTED 10dd00: c3 ret <== NOT EXECUTED 0010b4c0 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10b4c0: 55 push %ebp <== NOT EXECUTED 10b4c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4c3: 57 push %edi <== NOT EXECUTED 10b4c4: 56 push %esi <== NOT EXECUTED 10b4c5: 53 push %ebx <== NOT EXECUTED 10b4c6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10b4c9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b4cc: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue ) 10b4cf: 85 db test %ebx,%ebx <== NOT EXECUTED 10b4d1: 74 36 je 10b509 <_Thread_queue_Requeue+0x49> <== NOT EXECUTED /* * 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 ) { 10b4d3: 83 7b 34 01 cmpl $0x1,0x34(%ebx) <== NOT EXECUTED 10b4d7: 75 30 jne 10b509 <_Thread_queue_Requeue+0x49> <== NOT EXECUTED Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 10b4d9: 9c pushf <== NOT EXECUTED 10b4da: fa cli <== NOT EXECUTED 10b4db: 5f pop %edi <== NOT EXECUTED if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10b4dc: f7 46 10 e0 be 03 00 testl $0x3bee0,0x10(%esi) <== NOT EXECUTED 10b4e3: 74 22 je 10b507 <_Thread_queue_Requeue+0x47> <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10b4e5: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) <== NOT EXECUTED _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); 10b4ec: 50 push %eax <== NOT EXECUTED 10b4ed: 6a 01 push $0x1 <== NOT EXECUTED 10b4ef: 56 push %esi <== NOT EXECUTED 10b4f0: 53 push %ebx <== NOT EXECUTED 10b4f1: e8 06 27 00 00 call 10dbfc <_Thread_queue_Extract_priority_helper> <== NOT EXECUTED (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10b4f6: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10b4f9: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b4fc: 50 push %eax <== NOT EXECUTED 10b4fd: 56 push %esi <== NOT EXECUTED 10b4fe: 53 push %ebx <== NOT EXECUTED 10b4ff: e8 98 fd ff ff call 10b29c <_Thread_queue_Enqueue_priority> <== NOT EXECUTED 10b504: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _ISR_Enable( level ); 10b507: 57 push %edi <== NOT EXECUTED 10b508: 9d popf <== NOT EXECUTED } } 10b509: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b50c: 5b pop %ebx <== NOT EXECUTED 10b50d: 5e pop %esi <== NOT EXECUTED 10b50e: 5f pop %edi <== NOT EXECUTED 10b50f: c9 leave <== NOT EXECUTED 10b510: c3 ret <== NOT EXECUTED 0010b514 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 10b514: 55 push %ebp <== NOT EXECUTED 10b515: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b517: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10b51a: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b51d: 50 push %eax <== NOT EXECUTED 10b51e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b521: e8 ba f8 ff ff call 10ade0 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10b526: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b529: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 10b52d: 75 17 jne 10b546 <_Thread_queue_Timeout+0x32> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10b52f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b532: 50 push %eax <== NOT EXECUTED 10b533: e8 84 27 00 00 call 10dcbc <_Thread_queue_Process_timeout> <== NOT EXECUTED 10b538: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 10b53d: 48 dec %eax <== NOT EXECUTED 10b53e: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED 10b543: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Unnest_dispatch(); break; } } 10b546: c9 leave <== NOT EXECUTED 10b547: c3 ret <== NOT EXECUTED 0010d344 <_Timer_Manager_initialization>: */ void _Timer_Manager_initialization( uint32_t maximum_timers ) { 10d344: 55 push %ebp <== NOT EXECUTED 10d345: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d347: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10d34a: 6a 04 push $0x4 <== NOT EXECUTED 10d34c: 6a 00 push $0x0 <== NOT EXECUTED 10d34e: 6a 3c push $0x3c <== NOT EXECUTED 10d350: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d353: 6a 02 push $0x2 <== NOT EXECUTED 10d355: 6a 02 push $0x2 <== NOT EXECUTED 10d357: 68 74 ce 11 00 push $0x11ce74 <== NOT EXECUTED 10d35c: e8 f7 d2 ff ff call 10a658 <_Objects_Initialize_information> <== NOT EXECUTED /* * Initialize the pointer to the Timer Server TCB to NULL indicating * that task-based timer support is not initialized. */ _Timer_Server = NULL; 10d361: c7 05 b8 ce 11 00 00 movl $0x0,0x11ceb8 <== NOT EXECUTED 10d368: 00 00 00 <== NOT EXECUTED _Timer_Server_schedule_operation = NULL; 10d36b: c7 05 b4 ce 11 00 00 movl $0x0,0x11ceb4 <== NOT EXECUTED 10d372: 00 00 00 <== NOT EXECUTED 10d375: 83 c4 20 add $0x20,%esp <== NOT EXECUTED } 10d378: c9 leave <== NOT EXECUTED 10d379: c3 ret <== NOT EXECUTED 00113214 <_Timer_Server_body>: * @param[in] ignored is the the task argument that is ignored */ Thread _Timer_Server_body( uint32_t ignored ) { 113214: 55 push %ebp <== NOT EXECUTED 113215: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113217: 57 push %edi <== NOT EXECUTED 113218: 56 push %esi <== NOT EXECUTED 113219: 53 push %ebx <== NOT EXECUTED 11321a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 11321d: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 113220: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 113223: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 113226: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 113229: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) <== NOT EXECUTED 113230: 89 75 f0 mov %esi,-0x10(%ebp) <== NOT EXECUTED /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 113233: a1 30 29 13 00 mov 0x132930,%eax <== NOT EXECUTED 113238: a3 64 27 13 00 mov %eax,0x132764 <== NOT EXECUTED _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 11323d: a1 70 28 13 00 mov 0x132870,%eax <== NOT EXECUTED 113242: a3 60 27 13 00 mov %eax,0x132760 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 113247: a1 e0 27 13 00 mov 0x1327e0,%eax <== NOT EXECUTED 11324c: 40 inc %eax <== NOT EXECUTED 11324d: a3 e0 27 13 00 mov %eax,0x1327e0 <== NOT EXECUTED /* * Insert the timers that were inserted before we got to run. * This should be done with dispatching disabled. */ _Thread_Disable_dispatch(); _Timer_Server_process_insertions(); 113252: e8 6d ff ff ff call 1131c4 <_Timer_Server_process_insertions> <== NOT EXECUTED _Thread_Enable_dispatch(); 113257: e8 90 24 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED ticks = snapshot - _Timer_Server_ticks_last_time; else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; _Timer_Server_ticks_last_time = snapshot; _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire ); 11325c: 89 f7 mov %esi,%edi <== NOT EXECUTED 11325e: a1 e0 27 13 00 mov 0x1327e0,%eax <== NOT EXECUTED 113263: 40 inc %eax <== NOT EXECUTED 113264: a3 e0 27 13 00 mov %eax,0x1327e0 <== NOT EXECUTED /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 113269: 51 push %ecx <== NOT EXECUTED 11326a: 51 push %ecx <== NOT EXECUTED 11326b: 6a 08 push $0x8 <== NOT EXECUTED 11326d: ff 35 18 2b 13 00 pushl 0x132b18 <== NOT EXECUTED 113273: e8 90 2d 00 00 call 116008 <_Thread_Set_state> <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 113278: 8b 15 54 27 13 00 mov 0x132754,%edx <== NOT EXECUTED _Timer_Server_reset_ticks_timer(); 11327e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113281: 81 fa 58 27 13 00 cmp $0x132758,%edx <== NOT EXECUTED 113287: 74 1e je 1132a7 <_Timer_Server_body+0x93> <== NOT EXECUTED 113289: a1 18 2b 13 00 mov 0x132b18,%eax <== NOT EXECUTED Heap_Control *the_heap, 11328e: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 113291: 89 50 54 mov %edx,0x54(%eax) <== NOT EXECUTED void *starting_address, size_t *size 113294: 52 push %edx <== NOT EXECUTED 113295: 52 push %edx <== NOT EXECUTED 113296: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 113299: 50 push %eax <== NOT EXECUTED 11329a: 68 c0 28 13 00 push $0x1328c0 <== NOT EXECUTED 11329f: e8 64 35 00 00 call 116808 <_Watchdog_Insert> <== NOT EXECUTED 1132a4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 1132a7: a1 68 27 13 00 mov 0x132768,%eax <== NOT EXECUTED _Timer_Server_reset_seconds_timer(); 1132ac: 3d 6c 27 13 00 cmp $0x13276c,%eax <== NOT EXECUTED 1132b1: 74 1c je 1132cf <_Timer_Server_body+0xbb> <== NOT EXECUTED * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. */ bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, 1132b3: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 1132b6: a3 8c 27 13 00 mov %eax,0x13278c <== NOT EXECUTED size_t size ); 1132bb: 50 push %eax <== NOT EXECUTED 1132bc: 50 push %eax <== NOT EXECUTED 1132bd: 68 80 27 13 00 push $0x132780 <== NOT EXECUTED 1132c2: 68 b4 28 13 00 push $0x1328b4 <== NOT EXECUTED 1132c7: e8 3c 35 00 00 call 116808 <_Watchdog_Insert> <== NOT EXECUTED 1132cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Enable_dispatch(); 1132cf: e8 18 24 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1132d4: a1 e0 27 13 00 mov 0x1327e0,%eax <== NOT EXECUTED 1132d9: 40 inc %eax <== NOT EXECUTED 1132da: a3 e0 27 13 00 mov %eax,0x1327e0 <== NOT EXECUTED /* * At this point, at least one of the timers this task relies * upon has fired. Stop them both while we process any outstanding * timers. Before we block, we will restart them. */ _Timer_Server_stop_ticks_timer(); 1132df: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1132e2: a1 18 2b 13 00 mov 0x132b18,%eax <== NOT EXECUTED 1132e7: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 1132ea: 50 push %eax <== NOT EXECUTED 1132eb: e8 30 36 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED _Timer_Server_stop_seconds_timer(); 1132f0: c7 04 24 80 27 13 00 movl $0x132780,(%esp) <== NOT EXECUTED 1132f7: e8 24 36 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED ) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 1132fc: 8b 15 30 29 13 00 mov 0x132930,%edx <== NOT EXECUTED if ( snapshot >= _Timer_Server_ticks_last_time ) 113302: a1 64 27 13 00 mov 0x132764,%eax <== NOT EXECUTED 113307: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11330a: 39 c2 cmp %eax,%edx <== NOT EXECUTED 11330c: 72 08 jb 113316 <_Timer_Server_body+0x102> <== NOT EXECUTED ticks = snapshot - _Timer_Server_ticks_last_time; 11330e: 89 d1 mov %edx,%ecx <== NOT EXECUTED 113310: 29 c1 sub %eax,%ecx <== NOT EXECUTED 113312: 89 c8 mov %ecx,%eax <== NOT EXECUTED 113314: eb 04 jmp 11331a <_Timer_Server_body+0x106> <== NOT EXECUTED else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; 113316: f7 d0 not %eax <== NOT EXECUTED 113318: 01 d0 add %edx,%eax <== NOT EXECUTED _Timer_Server_ticks_last_time = snapshot; 11331a: 89 15 64 27 13 00 mov %edx,0x132764 <== NOT EXECUTED _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire ); 113320: 53 push %ebx <== NOT EXECUTED 113321: 57 push %edi <== NOT EXECUTED 113322: 50 push %eax <== NOT EXECUTED 113323: 68 54 27 13 00 push $0x132754 <== NOT EXECUTED 113328: e8 4b 34 00 00 call 116778 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED /* * 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 _Timer_Seconds_chain to indicate this. */ snapshot = _TOD_Seconds_since_epoch; 11332d: 8b 1d 70 28 13 00 mov 0x132870,%ebx <== NOT EXECUTED if ( snapshot > _Timer_Server_seconds_last_time ) { 113333: a1 60 27 13 00 mov 0x132760,%eax <== NOT EXECUTED 113338: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11333b: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 11333d: 76 13 jbe 113352 <_Timer_Server_body+0x13e> <== NOT EXECUTED /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ ticks = snapshot - _Timer_Server_seconds_last_time; _Watchdog_Adjust_to_chain( &_Timer_Seconds_chain, ticks, to_fire ); 11333f: 51 push %ecx <== NOT EXECUTED 113340: 57 push %edi <== NOT EXECUTED 113341: 89 da mov %ebx,%edx <== NOT EXECUTED 113343: 29 c2 sub %eax,%edx <== NOT EXECUTED 113345: 52 push %edx <== NOT EXECUTED 113346: 68 68 27 13 00 push $0x132768 <== NOT EXECUTED 11334b: e8 28 34 00 00 call 116778 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED 113350: eb 12 jmp 113364 <_Timer_Server_body+0x150> <== NOT EXECUTED } else if ( snapshot < _Timer_Server_seconds_last_time ) { 113352: 73 13 jae 113367 <_Timer_Server_body+0x153> <== NOT EXECUTED /* * The current TOD is before the last TOD which indicates that * TOD has been set backwards. */ ticks = _Timer_Server_seconds_last_time - snapshot; _Watchdog_Adjust( &_Timer_Seconds_chain, WATCHDOG_BACKWARD, ticks ); 113354: 52 push %edx <== NOT EXECUTED 113355: 29 d8 sub %ebx,%eax <== NOT EXECUTED 113357: 50 push %eax <== NOT EXECUTED 113358: 6a 01 push $0x1 <== NOT EXECUTED 11335a: 68 68 27 13 00 push $0x132768 <== NOT EXECUTED 11335f: e8 a8 33 00 00 call 11670c <_Watchdog_Adjust> <== NOT EXECUTED 113364: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _Timer_Server_seconds_last_time = snapshot; 113367: 89 1d 60 27 13 00 mov %ebx,0x132760 <== NOT EXECUTED _Timer_Server_process_seconds_chain( &to_fire ); /* * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); 11336d: e8 52 fe ff ff call 1131c4 <_Timer_Server_process_insertions> <== NOT EXECUTED /* * Enable dispatching to process the set that are ready "to fire." */ _Thread_Enable_dispatch(); 113372: e8 75 23 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED */ while (1) { Watchdog_Control *watch; ISR_Level level; _ISR_Disable( level ); 113377: 9c pushf <== NOT EXECUTED 113378: fa cli <== NOT EXECUTED 113379: 59 pop %ecx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 11337a: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 11337d: 3b 55 e0 cmp -0x20(%ebp),%edx <== NOT EXECUTED 113380: 74 0c je 11338e <_Timer_Server_body+0x17a> <== NOT EXECUTED 113382: 8b 02 mov (%edx),%eax <== NOT EXECUTED 113384: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 113387: 89 70 04 mov %esi,0x4(%eax) <== NOT EXECUTED watch = (Watchdog_Control *) _Chain_Get_unprotected( &to_fire ); if ( watch == NULL ) { 11338a: 85 d2 test %edx,%edx <== NOT EXECUTED 11338c: 75 07 jne 113395 <_Timer_Server_body+0x181> <== NOT EXECUTED _ISR_Enable( level ); 11338e: 51 push %ecx <== NOT EXECUTED 11338f: 9d popf <== NOT EXECUTED 113390: e9 c9 fe ff ff jmp 11325e <_Timer_Server_body+0x4a> <== NOT EXECUTED break; } watch->state = WATCHDOG_INACTIVE; 113395: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) <== NOT EXECUTED _ISR_Enable( level ); 11339c: 51 push %ecx <== NOT EXECUTED 11339d: 9d popf <== NOT EXECUTED (*watch->routine)( watch->id, watch->user_data ); 11339e: 53 push %ebx <== NOT EXECUTED 11339f: 53 push %ebx <== NOT EXECUTED 1133a0: ff 72 24 pushl 0x24(%edx) <== NOT EXECUTED 1133a3: ff 72 20 pushl 0x20(%edx) <== NOT EXECUTED 1133a6: ff 52 1c call *0x1c(%edx) <== NOT EXECUTED 1133a9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1133ac: eb c9 jmp 113377 <_Timer_Server_body+0x163> <== NOT EXECUTED 001131c4 <_Timer_Server_process_insertions>: * onto one of the Timer Server chains. * * @note It is only to be called from the Timer Server task. */ static void _Timer_Server_process_insertions(void) { 1131c4: 55 push %ebp <== NOT EXECUTED 1131c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1131c7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Timer_Control *the_timer; while ( 1 ) { the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted ); 1131ca: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1131cd: 68 74 27 13 00 push $0x132774 <== NOT EXECUTED 1131d2: e8 05 08 00 00 call 1139dc <_Chain_Get> <== NOT EXECUTED if ( the_timer == NULL ) 1131d7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1131da: 85 c0 test %eax,%eax <== NOT EXECUTED 1131dc: 74 34 je 113212 <_Timer_Server_process_insertions+0x4e> <== NOT EXECUTED break; if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { 1131de: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 1131e1: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 1131e4: 75 0d jne 1131f3 <_Timer_Server_process_insertions+0x2f> <== NOT EXECUTED _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 1131e6: 51 push %ecx <== NOT EXECUTED 1131e7: 51 push %ecx <== NOT EXECUTED 1131e8: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 1131eb: 50 push %eax <== NOT EXECUTED 1131ec: 68 54 27 13 00 push $0x132754 <== NOT EXECUTED 1131f1: eb 10 jmp 113203 <_Timer_Server_process_insertions+0x3f> <== NOT EXECUTED } else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 1131f3: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 1131f6: 75 13 jne 11320b <_Timer_Server_process_insertions+0x47> <== NOT EXECUTED _Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker ); 1131f8: 52 push %edx <== NOT EXECUTED 1131f9: 52 push %edx <== NOT EXECUTED 1131fa: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 1131fd: 50 push %eax <== NOT EXECUTED 1131fe: 68 68 27 13 00 push $0x132768 <== NOT EXECUTED 113203: e8 00 36 00 00 call 116808 <_Watchdog_Insert> <== NOT EXECUTED 113208: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); 11320b: e8 b4 ff ff ff call 1131c4 <_Timer_Server_process_insertions> <== NOT EXECUTED 113210: eb b8 jmp 1131ca <_Timer_Server_process_insertions+0x6> <== NOT EXECUTED } } 113212: c9 leave <== NOT EXECUTED 113213: c3 ret <== NOT EXECUTED 0011318b <_Timer_Server_schedule_operation_method>: * the directive invoking this is executed. */ static void _Timer_Server_schedule_operation_method( Timer_Control *the_timer ) { 11318b: 55 push %ebp <== NOT EXECUTED 11318c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11318e: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED _Chain_Append( &_Timer_To_be_inserted, &the_timer->Object.Node ); 113191: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 113194: 68 74 27 13 00 push $0x132774 <== NOT EXECUTED 113199: e8 1a 08 00 00 call 1139b8 <_Chain_Append> <== NOT EXECUTED _Watchdog_Remove( &_Timer_Server->Timer ); 11319e: a1 18 2b 13 00 mov 0x132b18,%eax <== NOT EXECUTED 1131a3: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 1131a6: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1131a9: e8 72 37 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED _Thread_Delay_ended( _Timer_Server->Object.id, NULL ); 1131ae: 59 pop %ecx <== NOT EXECUTED 1131af: 58 pop %eax <== NOT EXECUTED 1131b0: 6a 00 push $0x0 <== NOT EXECUTED 1131b2: a1 18 2b 13 00 mov 0x132b18,%eax <== NOT EXECUTED 1131b7: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1131ba: e8 b1 23 00 00 call 115570 <_Thread_Delay_ended> <== NOT EXECUTED 1131bf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1131c2: c9 leave <== NOT EXECUTED 1131c3: c3 ret <== NOT EXECUTED 0010b8e8 <_Timespec_Add_to>: uint32_t _Timespec_Add_to( struct timespec *time, const struct timespec *add ) { 10b8e8: 55 push %ebp <== NOT EXECUTED 10b8e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b8eb: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b8ee: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED uint32_t seconds = add->tv_sec; 10b8f1: 8b 08 mov (%eax),%ecx <== NOT EXECUTED /* Add the basics */ time->tv_sec += add->tv_sec; 10b8f3: 01 0a add %ecx,(%edx) <== NOT EXECUTED time->tv_nsec += add->tv_nsec; 10b8f5: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10b8f8: 01 42 04 add %eax,0x4(%edx) <== NOT EXECUTED 10b8fb: eb 0b jmp 10b908 <_Timespec_Add_to+0x20> <== NOT EXECUTED /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 10b8fd: 2d 00 ca 9a 3b sub $0x3b9aca00,%eax <== NOT EXECUTED 10b902: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED time->tv_sec++; 10b905: ff 02 incl (%edx) <== NOT EXECUTED seconds++; 10b907: 41 inc %ecx <== NOT EXECUTED /* 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 ) { 10b908: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10b90b: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 10b910: 77 eb ja 10b8fd <_Timespec_Add_to+0x15> <== NOT EXECUTED time->tv_sec++; seconds++; } return seconds; } 10b912: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b914: c9 leave <== NOT EXECUTED 10b915: c3 ret <== NOT EXECUTED 0010ce38 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 10ce38: 55 push %ebp <== NOT EXECUTED 10ce39: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ce3b: 57 push %edi <== NOT EXECUTED 10ce3c: 56 push %esi <== NOT EXECUTED 10ce3d: 53 push %ebx <== NOT EXECUTED 10ce3e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10ce41: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10ce44: 8b 18 mov (%eax),%ebx <== NOT EXECUTED left += lhs->tv_nsec; 10ce46: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10ce49: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10ce4c: b8 00 ca 9a 3b mov $0x3b9aca00,%eax <== NOT EXECUTED 10ce51: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10ce54: f7 29 imull (%ecx) <== NOT EXECUTED 10ce56: 89 c6 mov %eax,%esi <== NOT EXECUTED 10ce58: 89 d7 mov %edx,%edi <== NOT EXECUTED right += rhs->tv_nsec; 10ce5a: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10ce5d: 99 cltd <== NOT EXECUTED 10ce5e: 01 c6 add %eax,%esi <== NOT EXECUTED 10ce60: 11 d7 adc %edx,%edi <== NOT EXECUTED if ( right == 0 ) { 10ce62: 89 f8 mov %edi,%eax <== NOT EXECUTED 10ce64: 09 f0 or %esi,%eax <== NOT EXECUTED 10ce66: 75 14 jne 10ce7c <_Timespec_Divide+0x44> <== NOT EXECUTED *ival_percentage = 0; 10ce68: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10ce6b: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED *fval_percentage = 0; 10ce71: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10ce74: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED 10ce7a: eb 70 jmp 10ceec <_Timespec_Divide+0xb4> <== NOT EXECUTED /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10ce7c: b8 00 ca 9a 3b mov $0x3b9aca00,%eax <== NOT EXECUTED 10ce81: f7 eb imul %ebx <== NOT EXECUTED 10ce83: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 10ce86: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 10ce89: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10ce8c: 99 cltd <== NOT EXECUTED 10ce8d: 01 45 e8 add %eax,-0x18(%ebp) <== NOT EXECUTED 10ce90: 11 55 ec adc %edx,-0x14(%ebp) <== NOT EXECUTED 10ce93: 69 5d ec a0 86 01 00 imul $0x186a0,-0x14(%ebp),%ebx <== NOT EXECUTED 10ce9a: b9 a0 86 01 00 mov $0x186a0,%ecx <== NOT EXECUTED 10ce9f: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10cea2: f7 e1 mul %ecx <== NOT EXECUTED 10cea4: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED 10cea7: 01 da add %ebx,%edx <== NOT EXECUTED 10cea9: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED 10ceac: 57 push %edi <== NOT EXECUTED 10cead: 56 push %esi <== NOT EXECUTED 10ceae: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED 10ceb1: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 10ceb4: e8 8f a4 00 00 call 117348 <__udivdi3> <== NOT EXECUTED 10ceb9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cebc: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10cebe: 89 d6 mov %edx,%esi <== NOT EXECUTED *ival_percentage = answer / 1000; 10cec0: 6a 00 push $0x0 <== NOT EXECUTED 10cec2: 68 e8 03 00 00 push $0x3e8 <== NOT EXECUTED 10cec7: 52 push %edx <== NOT EXECUTED 10cec8: 50 push %eax <== NOT EXECUTED 10cec9: e8 7a a4 00 00 call 117348 <__udivdi3> <== NOT EXECUTED 10cece: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ced1: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10ced4: 89 01 mov %eax,(%ecx) <== NOT EXECUTED *fval_percentage = answer % 1000; 10ced6: 6a 00 push $0x0 <== NOT EXECUTED 10ced8: 68 e8 03 00 00 push $0x3e8 <== NOT EXECUTED 10cedd: 56 push %esi <== NOT EXECUTED 10cede: 53 push %ebx <== NOT EXECUTED 10cedf: e8 70 a5 00 00 call 117454 <__umoddi3> <== NOT EXECUTED 10cee4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cee7: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10ceea: 89 01 mov %eax,(%ecx) <== NOT EXECUTED } 10ceec: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ceef: 5b pop %ebx <== NOT EXECUTED 10cef0: 5e pop %esi <== NOT EXECUTED 10cef1: 5f pop %edi <== NOT EXECUTED 10cef2: c9 leave <== NOT EXECUTED 10cef3: c3 ret <== NOT EXECUTED 00122208 <_Timespec_Divide_by_integer>: void _Timespec_Divide_by_integer( const struct timespec *time, uint32_t iterations, struct timespec *result ) { 122208: 55 push %ebp <== NOT EXECUTED 122209: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12220b: 57 push %edi <== NOT EXECUTED 12220c: 56 push %esi <== NOT EXECUTED 12220d: 53 push %ebx <== NOT EXECUTED 12220e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 122211: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 122214: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ t = time->tv_sec; 122217: 8b 06 mov (%esi),%eax <== NOT EXECUTED 122219: 99 cltd <== NOT EXECUTED t *= TOD_NANOSECONDS_PER_SECOND; 12221a: 69 da 00 ca 9a 3b imul $0x3b9aca00,%edx,%ebx <== NOT EXECUTED 122220: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx <== NOT EXECUTED 122225: f7 e1 mul %ecx <== NOT EXECUTED 122227: 8d 14 13 lea (%ebx,%edx,1),%edx <== NOT EXECUTED t += time->tv_nsec; 12222a: 8b 4e 04 mov 0x4(%esi),%ecx <== NOT EXECUTED 12222d: 89 cb mov %ecx,%ebx <== NOT EXECUTED 12222f: c1 fb 1f sar $0x1f,%ebx <== NOT EXECUTED 122232: 01 c8 add %ecx,%eax <== NOT EXECUTED 122234: 11 da adc %ebx,%edx <== NOT EXECUTED /* * Divide to get nanoseconds per iteration */ t /= iterations; 122236: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 122239: 31 db xor %ebx,%ebx <== NOT EXECUTED 12223b: 53 push %ebx <== NOT EXECUTED 12223c: 51 push %ecx <== NOT EXECUTED 12223d: 52 push %edx <== NOT EXECUTED 12223e: 50 push %eax <== NOT EXECUTED 12223f: e8 98 66 01 00 call 1388dc <__udivdi3> <== NOT EXECUTED 122244: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 122247: 89 c3 mov %eax,%ebx <== NOT EXECUTED 122249: 89 d6 mov %edx,%esi <== NOT EXECUTED /* * Put it back in the timespec result */ result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND; 12224b: 6a 00 push $0x0 <== NOT EXECUTED 12224d: 68 00 ca 9a 3b push $0x3b9aca00 <== NOT EXECUTED 122252: 52 push %edx <== NOT EXECUTED 122253: 50 push %eax <== NOT EXECUTED 122254: e8 83 66 01 00 call 1388dc <__udivdi3> <== NOT EXECUTED 122259: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12225c: 89 07 mov %eax,(%edi) <== NOT EXECUTED result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND; 12225e: 6a 00 push $0x0 <== NOT EXECUTED 122260: 68 00 ca 9a 3b push $0x3b9aca00 <== NOT EXECUTED 122265: 56 push %esi <== NOT EXECUTED 122266: 53 push %ebx <== NOT EXECUTED 122267: e8 7c 67 01 00 call 1389e8 <__umoddi3> <== NOT EXECUTED 12226c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12226f: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED } 122272: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 122275: 5b pop %ebx <== NOT EXECUTED 122276: 5e pop %esi <== NOT EXECUTED 122277: 5f pop %edi <== NOT EXECUTED 122278: c9 leave <== NOT EXECUTED 122279: c3 ret <== NOT EXECUTED 001133cc <_Timespec_From_ticks>: void _Timespec_From_ticks( uint32_t ticks, struct timespec *time ) { 1133cc: 55 push %ebp <== NOT EXECUTED 1133cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1133cf: 56 push %esi <== NOT EXECUTED 1133d0: 53 push %ebx <== NOT EXECUTED 1133d1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1133d4: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED uint32_t usecs; usecs = ticks * _TOD_Microseconds_per_tick; 1133d7: 0f af 1d 20 8a 12 00 imul 0x128a20,%ebx <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 1133de: be 40 42 0f 00 mov $0xf4240,%esi <== NOT EXECUTED 1133e3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1133e5: 31 d2 xor %edx,%edx <== NOT EXECUTED 1133e7: f7 f6 div %esi <== NOT EXECUTED 1133e9: 89 01 mov %eax,(%ecx) <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 1133eb: 69 c2 e8 03 00 00 imul $0x3e8,%edx,%eax <== NOT EXECUTED 1133f1: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED TOD_NANOSECONDS_PER_MICROSECOND; } 1133f4: 5b pop %ebx <== NOT EXECUTED 1133f5: 5e pop %esi <== NOT EXECUTED 1133f6: c9 leave <== NOT EXECUTED 1133f7: c3 ret <== NOT EXECUTED 0010d180 <_Timespec_Greater_than>: bool _Timespec_Greater_than( const struct timespec *lhs, const struct timespec *rhs ) { 10d180: 55 push %ebp <== NOT EXECUTED 10d181: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d183: 53 push %ebx <== NOT EXECUTED 10d184: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10d187: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED if ( lhs->tv_sec > rhs->tv_sec ) 10d18a: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10d18c: b2 01 mov $0x1,%dl <== NOT EXECUTED 10d18e: 39 01 cmp %eax,(%ecx) <== NOT EXECUTED 10d190: 7f 0f jg 10d1a1 <_Timespec_Greater_than+0x21> <== NOT EXECUTED return TRUE; if ( lhs->tv_sec < rhs->tv_sec ) 10d192: 7d 04 jge 10d198 <_Timespec_Greater_than+0x18> <== NOT EXECUTED 10d194: 31 d2 xor %edx,%edx <== NOT EXECUTED 10d196: eb 09 jmp 10d1a1 <_Timespec_Greater_than+0x21> <== NOT EXECUTED return FALSE; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec > rhs->tv_nsec ) 10d198: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d19b: 3b 43 04 cmp 0x4(%ebx),%eax <== NOT EXECUTED 10d19e: 0f 9f c2 setg %dl <== NOT EXECUTED return TRUE; return FALSE; } 10d1a1: 88 d0 mov %dl,%al <== NOT EXECUTED 10d1a3: 5b pop %ebx <== NOT EXECUTED 10d1a4: c9 leave <== NOT EXECUTED 10d1a5: c3 ret <== NOT EXECUTED 001133f8 <_Timespec_Is_valid>: #include bool _Timespec_Is_valid( const struct timespec *time ) { 1133f8: 55 push %ebp <== NOT EXECUTED 1133f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1133fb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !time ) 1133fe: 85 c0 test %eax,%eax <== NOT EXECUTED 113400: 74 16 je 113418 <_Timespec_Is_valid+0x20> <== NOT EXECUTED return FALSE; if ( time->tv_sec < 0 ) 113402: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 113405: 78 11 js 113418 <_Timespec_Is_valid+0x20> <== NOT EXECUTED return FALSE; if ( time->tv_nsec < 0 ) 113407: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 11340a: 85 c0 test %eax,%eax <== NOT EXECUTED 11340c: 78 0a js 113418 <_Timespec_Is_valid+0x20> <== NOT EXECUTED 11340e: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 113413: 0f 96 c0 setbe %al <== NOT EXECUTED 113416: eb 02 jmp 11341a <_Timespec_Is_valid+0x22> <== NOT EXECUTED 113418: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return FALSE; return TRUE; } 11341a: c9 leave <== NOT EXECUTED 11341b: c3 ret <== NOT EXECUTED 0010d1a8 <_Timespec_Less_than>: bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { 10d1a8: 55 push %ebp <== NOT EXECUTED 10d1a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d1ab: 53 push %ebx <== NOT EXECUTED 10d1ac: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10d1af: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED if ( lhs->tv_sec < rhs->tv_sec ) 10d1b2: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10d1b4: b2 01 mov $0x1,%dl <== NOT EXECUTED 10d1b6: 39 01 cmp %eax,(%ecx) <== NOT EXECUTED 10d1b8: 7c 0f jl 10d1c9 <_Timespec_Less_than+0x21> <== NOT EXECUTED return TRUE; if ( lhs->tv_sec > rhs->tv_sec ) 10d1ba: 7e 04 jle 10d1c0 <_Timespec_Less_than+0x18> <== NOT EXECUTED 10d1bc: 31 d2 xor %edx,%edx <== NOT EXECUTED 10d1be: eb 09 jmp 10d1c9 <_Timespec_Less_than+0x21> <== NOT EXECUTED return FALSE; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) 10d1c0: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d1c3: 3b 43 04 cmp 0x4(%ebx),%eax <== NOT EXECUTED 10d1c6: 0f 9c c2 setl %dl <== NOT EXECUTED return TRUE; return FALSE; } 10d1c9: 88 d0 mov %dl,%al <== NOT EXECUTED 10d1cb: 5b pop %ebx <== NOT EXECUTED 10d1cc: c9 leave <== NOT EXECUTED 10d1cd: c3 ret <== NOT EXECUTED 0010b918 <_Timespec_Subtract>: void _Timespec_Subtract( const struct timespec *start, const struct timespec *end, struct timespec *result ) { 10b918: 55 push %ebp <== NOT EXECUTED 10b919: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b91b: 53 push %ebx <== NOT EXECUTED 10b91c: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b91f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b922: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED if (end->tv_nsec < start->tv_nsec) { 10b925: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 10b928: 3b 51 04 cmp 0x4(%ecx),%edx <== NOT EXECUTED 10b92b: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10b92d: 7d 13 jge 10b942 <_Timespec_Subtract+0x2a> <== NOT EXECUTED result->tv_sec = end->tv_sec - start->tv_sec - 1; 10b92f: 48 dec %eax <== NOT EXECUTED 10b930: 2b 01 sub (%ecx),%eax <== NOT EXECUTED 10b932: 89 03 mov %eax,(%ebx) <== NOT EXECUTED result->tv_nsec = 10b934: 8d 82 00 ca 9a 3b lea 0x3b9aca00(%edx),%eax <== NOT EXECUTED 10b93a: 2b 41 04 sub 0x4(%ecx),%eax <== NOT EXECUTED 10b93d: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED 10b940: eb 0a jmp 10b94c <_Timespec_Subtract+0x34> <== NOT EXECUTED (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec; } else { result->tv_sec = end->tv_sec - start->tv_sec; 10b942: 2b 01 sub (%ecx),%eax <== NOT EXECUTED 10b944: 89 03 mov %eax,(%ebx) <== NOT EXECUTED result->tv_nsec = end->tv_nsec - start->tv_nsec; 10b946: 2b 51 04 sub 0x4(%ecx),%edx <== NOT EXECUTED 10b949: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED } } 10b94c: 5b pop %ebx <== NOT EXECUTED 10b94d: c9 leave <== NOT EXECUTED 10b94e: c3 ret <== NOT EXECUTED 0011341c <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 11341c: 55 push %ebp <== NOT EXECUTED 11341d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11341f: 57 push %edi <== NOT EXECUTED 113420: 56 push %esi <== NOT EXECUTED 113421: 53 push %ebx <== NOT EXECUTED 113422: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113425: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 113428: 8b 31 mov (%ecx),%esi <== NOT EXECUTED 11342a: 85 f6 test %esi,%esi <== NOT EXECUTED 11342c: 75 08 jne 113436 <_Timespec_To_ticks+0x1a> <== NOT EXECUTED 11342e: 31 c0 xor %eax,%eax <== NOT EXECUTED 113430: 83 79 04 00 cmpl $0x0,0x4(%ecx) <== NOT EXECUTED 113434: 74 2f je 113465 <_Timespec_To_ticks+0x49> <== NOT EXECUTED return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 113436: 8b 1d 20 8a 12 00 mov 0x128a20,%ebx <== NOT EXECUTED 11343c: bf 40 42 0f 00 mov $0xf4240,%edi <== NOT EXECUTED 113441: 89 f8 mov %edi,%eax <== NOT EXECUTED 113443: 31 d2 xor %edx,%edx <== NOT EXECUTED 113445: f7 f3 div %ebx <== NOT EXECUTED 113447: 89 c7 mov %eax,%edi <== NOT EXECUTED 113449: 0f af fe imul %esi,%edi <== NOT EXECUTED ticks += (time->tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND) / 11344c: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 11344f: b9 e8 03 00 00 mov $0x3e8,%ecx <== NOT EXECUTED 113454: 31 d2 xor %edx,%edx <== NOT EXECUTED 113456: f7 f1 div %ecx <== NOT EXECUTED 113458: 31 d2 xor %edx,%edx <== NOT EXECUTED 11345a: f7 f3 div %ebx <== NOT EXECUTED _TOD_Microseconds_per_tick; if (ticks) 11345c: 01 f8 add %edi,%eax <== NOT EXECUTED 11345e: 75 05 jne 113465 <_Timespec_To_ticks+0x49> <== NOT EXECUTED 113460: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED return ticks; return 1; } 113465: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 113468: 5b pop %ebx <== NOT EXECUTED 113469: 5e pop %esi <== NOT EXECUTED 11346a: 5f pop %edi <== NOT EXECUTED 11346b: c9 leave <== NOT EXECUTED 11346c: c3 ret <== NOT EXECUTED 0010ddfc <_User_extensions_Add_API_set>: */ void _User_extensions_Add_API_set ( User_extensions_Control *the_extension ) { 10ddfc: 55 push %ebp <== NOT EXECUTED 10ddfd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ddff: 53 push %ebx <== NOT EXECUTED 10de00: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10de03: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED _Chain_Append( &_User_extensions_List, &the_extension->Node ); 10de06: 53 push %ebx <== NOT EXECUTED 10de07: 68 18 cc 11 00 push $0x11cc18 <== NOT EXECUTED 10de0c: e8 0f bc ff ff call 109a20 <_Chain_Append> <== NOT EXECUTED /* * If a switch handler is present, append it to the switch chain. */ if ( the_extension->Callouts.thread_switch != NULL ) { 10de11: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 10de14: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10de17: 85 c0 test %eax,%eax <== NOT EXECUTED 10de19: 74 16 je 10de31 <_User_extensions_Add_API_set+0x35> <== NOT EXECUTED the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch; 10de1b: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _Chain_Append( 10de1e: 50 push %eax <== NOT EXECUTED 10de1f: 50 push %eax <== NOT EXECUTED 10de20: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10de23: 50 push %eax <== NOT EXECUTED 10de24: 68 04 ca 11 00 push $0x11ca04 <== NOT EXECUTED 10de29: e8 f2 bb ff ff call 109a20 <_Chain_Append> <== NOT EXECUTED 10de2e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10de31: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10de34: c9 leave <== NOT EXECUTED 10de35: c3 ret <== NOT EXECUTED 0010de38 <_User_extensions_Add_set>: void _User_extensions_Add_set ( User_extensions_Control *the_extension, User_extensions_Table *extension_table ) { 10de38: 55 push %ebp <== NOT EXECUTED 10de39: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10de3b: 57 push %edi <== NOT EXECUTED 10de3c: 56 push %esi <== NOT EXECUTED 10de3d: 53 push %ebx <== NOT EXECUTED 10de3e: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10de41: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10de44: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10de47: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED the_extension->Callouts = *extension_table; 10de4a: 8d 7b 14 lea 0x14(%ebx),%edi <== NOT EXECUTED 10de4d: b9 08 00 00 00 mov $0x8,%ecx <== NOT EXECUTED 10de52: 89 c6 mov %eax,%esi <== NOT EXECUTED 10de54: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED _Chain_Append( &_User_extensions_List, &the_extension->Node ); 10de56: 53 push %ebx <== NOT EXECUTED 10de57: 68 18 cc 11 00 push $0x11cc18 <== NOT EXECUTED 10de5c: e8 bf bb ff ff call 109a20 <_Chain_Append> <== NOT EXECUTED /* * If a switch handler is present, append it to the switch chain. */ if ( extension_table->thread_switch != NULL ) { 10de61: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10de64: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10de67: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10de6a: 85 c0 test %eax,%eax <== NOT EXECUTED 10de6c: 74 1c je 10de8a <_User_extensions_Add_set+0x52> <== NOT EXECUTED the_extension->Switch.thread_switch = extension_table->thread_switch; 10de6e: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _Chain_Append( 10de71: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10de74: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10de77: c7 45 08 04 ca 11 00 movl $0x11ca04,0x8(%ebp) <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10de7e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10de81: 5b pop %ebx <== NOT EXECUTED 10de82: 5e pop %esi <== NOT EXECUTED 10de83: 5f pop %edi <== NOT EXECUTED 10de84: c9 leave <== NOT EXECUTED * If a switch handler is present, append it to the switch chain. */ if ( extension_table->thread_switch != NULL ) { the_extension->Switch.thread_switch = extension_table->thread_switch; _Chain_Append( 10de85: e9 96 bb ff ff jmp 109a20 <_Chain_Append> <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10de8a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10de8d: 5b pop %ebx <== NOT EXECUTED 10de8e: 5e pop %esi <== NOT EXECUTED 10de8f: 5f pop %edi <== NOT EXECUTED 10de90: c9 leave <== NOT EXECUTED 10de91: c3 ret <== NOT EXECUTED 0010ba3f <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) { 10ba3f: 55 push %ebp <== NOT EXECUTED 10ba40: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ba42: 57 push %edi <== NOT EXECUTED 10ba43: 56 push %esi <== NOT EXECUTED 10ba44: 53 push %ebx <== NOT EXECUTED 10ba45: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ba48: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10ba4b: 8b 1d 20 cc 11 00 mov 0x11cc20,%ebx <== NOT EXECUTED 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 ); 10ba51: 0f b6 75 0c movzbl 0xc(%ebp),%esi <== NOT EXECUTED 10ba55: eb 15 jmp 10ba6c <_User_extensions_Fatal+0x2d> <== NOT EXECUTED !_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 ) 10ba57: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10ba5a: 85 c0 test %eax,%eax <== NOT EXECUTED 10ba5c: 74 0b je 10ba69 <_User_extensions_Fatal+0x2a> <== NOT EXECUTED (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10ba5e: 52 push %edx <== NOT EXECUTED 10ba5f: 57 push %edi <== NOT EXECUTED 10ba60: 56 push %esi <== NOT EXECUTED 10ba61: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ba64: ff d0 call *%eax <== NOT EXECUTED 10ba66: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 10ba69: 8b 5b 04 mov 0x4(%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10ba6c: 81 fb 18 cc 11 00 cmp $0x11cc18,%ebx <== NOT EXECUTED 10ba72: 75 e3 jne 10ba57 <_User_extensions_Fatal+0x18> <== NOT EXECUTED the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 10ba74: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ba77: 5b pop %ebx <== NOT EXECUTED 10ba78: 5e pop %esi <== NOT EXECUTED 10ba79: 5f pop %edi <== NOT EXECUTED 10ba7a: c9 leave <== NOT EXECUTED 10ba7b: c3 ret <== NOT EXECUTED 0010b950 <_User_extensions_Handler_initialization>: void _User_extensions_Handler_initialization ( uint32_t number_of_extensions, User_extensions_Table *initial_extensions ) { 10b950: 55 push %ebp <== NOT EXECUTED 10b951: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b953: 57 push %edi <== NOT EXECUTED 10b954: 56 push %esi <== NOT EXECUTED 10b955: 53 push %ebx <== NOT EXECUTED 10b956: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b959: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10b95c: c7 05 18 cc 11 00 1c movl $0x11cc1c,0x11cc18 <== NOT EXECUTED 10b963: cc 11 00 <== NOT EXECUTED 10b966: c7 05 1c cc 11 00 00 movl $0x0,0x11cc1c <== NOT EXECUTED 10b96d: 00 00 00 <== NOT EXECUTED 10b970: c7 05 20 cc 11 00 18 movl $0x11cc18,0x11cc20 <== NOT EXECUTED 10b977: cc 11 00 <== NOT EXECUTED 10b97a: c7 05 04 ca 11 00 08 movl $0x11ca08,0x11ca04 <== NOT EXECUTED 10b981: ca 11 00 <== NOT EXECUTED 10b984: c7 05 08 ca 11 00 00 movl $0x0,0x11ca08 <== NOT EXECUTED 10b98b: 00 00 00 <== NOT EXECUTED 10b98e: c7 05 0c ca 11 00 04 movl $0x11ca04,0x11ca0c <== NOT EXECUTED 10b995: ca 11 00 <== NOT EXECUTED uint32_t i; _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10b998: 85 f6 test %esi,%esi <== NOT EXECUTED 10b99a: 74 38 je 10b9d4 <_User_extensions_Handler_initialization+0x84> <== NOT EXECUTED extension = (User_extensions_Control *) 10b99c: 6b 5d 08 34 imul $0x34,0x8(%ebp),%ebx <== NOT EXECUTED 10b9a0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b9a3: 53 push %ebx <== NOT EXECUTED 10b9a4: e8 c9 03 00 00 call 10bd72 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10b9a9: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10b9ac: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b9ae: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 10b9b1: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 10b9b3: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 10b9b5: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b9b7: eb 13 jmp 10b9cc <_User_extensions_Handler_initialization+0x7c> <== NOT EXECUTED 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { _User_extensions_Add_set (extension, &initial_extensions[i]); 10b9b9: 50 push %eax <== NOT EXECUTED 10b9ba: 50 push %eax <== NOT EXECUTED 10b9bb: 56 push %esi <== NOT EXECUTED 10b9bc: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10b9bf: e8 74 24 00 00 call 10de38 <_User_extensions_Add_set> <== NOT EXECUTED extension++; 10b9c4: 83 45 ec 34 addl $0x34,-0x14(%ebp) <== NOT EXECUTED extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10b9c8: 43 inc %ebx <== NOT EXECUTED 10b9c9: 83 c6 20 add $0x20,%esi <== NOT EXECUTED 10b9cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b9cf: 3b 5d 08 cmp 0x8(%ebp),%ebx <== NOT EXECUTED 10b9d2: 72 e5 jb 10b9b9 <_User_extensions_Handler_initialization+0x69> <== NOT EXECUTED _User_extensions_Add_set (extension, &initial_extensions[i]); extension++; } } } 10b9d4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b9d7: 5b pop %ebx <== NOT EXECUTED 10b9d8: 5e pop %esi <== NOT EXECUTED 10b9d9: 5f pop %edi <== NOT EXECUTED 10b9da: c9 leave <== NOT EXECUTED 10b9db: c3 ret <== NOT EXECUTED 0010f0e0 <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 10f0e0: 55 push %ebp <== NOT EXECUTED 10f0e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f0e3: 53 push %ebx <== NOT EXECUTED 10f0e4: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10f0e7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED _Chain_Extract( &the_extension->Node ); 10f0ea: 53 push %ebx <== NOT EXECUTED 10f0eb: e8 0c 38 00 00 call 1128fc <_Chain_Extract> <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 10f0f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f0f3: 83 7b 24 00 cmpl $0x0,0x24(%ebx) <== NOT EXECUTED 10f0f7: 74 0f je 10f108 <_User_extensions_Remove_set+0x28> <== NOT EXECUTED _Chain_Extract( &the_extension->Switch.Node ); 10f0f9: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10f0fc: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10f0ff: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f102: c9 leave <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) _Chain_Extract( &the_extension->Switch.Node ); 10f103: e9 f4 37 00 00 jmp 1128fc <_Chain_Extract> <== NOT EXECUTED } 10f108: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f10b: c9 leave <== NOT EXECUTED 10f10c: c3 ret <== NOT EXECUTED 0010b9dc <_User_extensions_Thread_begin>: */ void _User_extensions_Thread_begin ( Thread_Control *executing ) { 10b9dc: 55 push %ebp <== NOT EXECUTED 10b9dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b9df: 56 push %esi <== NOT EXECUTED 10b9e0: 53 push %ebx <== NOT EXECUTED 10b9e1: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; 10b9e4: 8b 1d 18 cc 11 00 mov 0x11cc18,%ebx <== NOT EXECUTED 10b9ea: eb 12 jmp 10b9fe <_User_extensions_Thread_begin+0x22> <== NOT EXECUTED !_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 ) 10b9ec: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 10b9ef: 85 c0 test %eax,%eax <== NOT EXECUTED 10b9f1: 74 09 je 10b9fc <_User_extensions_Thread_begin+0x20> <== NOT EXECUTED (*the_extension->Callouts.thread_begin)( executing ); 10b9f3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b9f6: 56 push %esi <== NOT EXECUTED 10b9f7: ff d0 call *%eax <== NOT EXECUTED 10b9f9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10b9fc: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10b9fe: 81 fb 1c cc 11 00 cmp $0x11cc1c,%ebx <== NOT EXECUTED 10ba04: 75 e6 jne 10b9ec <_User_extensions_Thread_begin+0x10> <== NOT EXECUTED the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_begin != NULL ) (*the_extension->Callouts.thread_begin)( executing ); } } 10ba06: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ba09: 5b pop %ebx <== NOT EXECUTED 10ba0a: 5e pop %esi <== NOT EXECUTED 10ba0b: c9 leave <== NOT EXECUTED 10ba0c: c3 ret <== NOT EXECUTED 0010ba7c <_User_extensions_Thread_create>: */ bool _User_extensions_Thread_create ( Thread_Control *the_thread ) { 10ba7c: 55 push %ebp <== NOT EXECUTED 10ba7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ba7f: 56 push %esi <== NOT EXECUTED 10ba80: 53 push %ebx <== NOT EXECUTED 10ba81: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _User_extensions_List.first ; 10ba84: 8b 1d 18 cc 11 00 mov 0x11cc18,%ebx <== NOT EXECUTED 10ba8a: eb 1b jmp 10baa7 <_User_extensions_Thread_create+0x2b> <== NOT EXECUTED !_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 ) { 10ba8c: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10ba8f: 85 c0 test %eax,%eax <== NOT EXECUTED 10ba91: 74 12 je 10baa5 <_User_extensions_Thread_create+0x29> <== NOT EXECUTED status = (*the_extension->Callouts.thread_create)( 10ba93: 52 push %edx <== NOT EXECUTED 10ba94: 52 push %edx <== NOT EXECUTED 10ba95: 56 push %esi <== NOT EXECUTED 10ba96: ff 35 c0 ca 11 00 pushl 0x11cac0 <== NOT EXECUTED 10ba9c: ff d0 call *%eax <== NOT EXECUTED _Thread_Executing, the_thread ); if ( !status ) 10ba9e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10baa1: 84 c0 test %al,%al <== NOT EXECUTED 10baa3: 74 0c je 10bab1 <_User_extensions_Thread_create+0x35> <== NOT EXECUTED User_extensions_Control *the_extension; bool status; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10baa5: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10baa7: 81 fb 1c cc 11 00 cmp $0x11cc1c,%ebx <== NOT EXECUTED 10baad: 75 dd jne 10ba8c <_User_extensions_Thread_create+0x10> <== NOT EXECUTED 10baaf: b0 01 mov $0x1,%al <== NOT EXECUTED return FALSE; } } return TRUE; } 10bab1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10bab4: 5b pop %ebx <== NOT EXECUTED 10bab5: 5e pop %esi <== NOT EXECUTED 10bab6: c9 leave <== NOT EXECUTED 10bab7: c3 ret <== NOT EXECUTED 0010bab8 <_User_extensions_Thread_delete>: */ void _User_extensions_Thread_delete ( Thread_Control *the_thread ) { 10bab8: 55 push %ebp <== NOT EXECUTED 10bab9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10babb: 56 push %esi <== NOT EXECUTED 10babc: 53 push %ebx <== NOT EXECUTED 10babd: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10bac0: 8b 1d 20 cc 11 00 mov 0x11cc20,%ebx <== NOT EXECUTED 10bac6: eb 18 jmp 10bae0 <_User_extensions_Thread_delete+0x28> <== NOT EXECUTED !_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 ) 10bac8: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 10bacb: 85 c0 test %eax,%eax <== NOT EXECUTED 10bacd: 74 0e je 10badd <_User_extensions_Thread_delete+0x25> <== NOT EXECUTED (*the_extension->Callouts.thread_delete)( 10bacf: 52 push %edx <== NOT EXECUTED 10bad0: 52 push %edx <== NOT EXECUTED 10bad1: 56 push %esi <== NOT EXECUTED 10bad2: ff 35 c0 ca 11 00 pushl 0x11cac0 <== NOT EXECUTED 10bad8: ff d0 call *%eax <== NOT EXECUTED 10bada: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 10badd: 8b 5b 04 mov 0x4(%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10bae0: 81 fb 18 cc 11 00 cmp $0x11cc18,%ebx <== NOT EXECUTED 10bae6: 75 e0 jne 10bac8 <_User_extensions_Thread_delete+0x10> <== NOT EXECUTED (*the_extension->Callouts.thread_delete)( _Thread_Executing, the_thread ); } } 10bae8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10baeb: 5b pop %ebx <== NOT EXECUTED 10baec: 5e pop %esi <== NOT EXECUTED 10baed: c9 leave <== NOT EXECUTED 10baee: c3 ret <== NOT EXECUTED 0010ba0d <_User_extensions_Thread_exitted>: */ void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 10ba0d: 55 push %ebp <== NOT EXECUTED 10ba0e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ba10: 56 push %esi <== NOT EXECUTED 10ba11: 53 push %ebx <== NOT EXECUTED 10ba12: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10ba15: 8b 1d 20 cc 11 00 mov 0x11cc20,%ebx <== NOT EXECUTED 10ba1b: eb 13 jmp 10ba30 <_User_extensions_Thread_exitted+0x23> <== NOT EXECUTED !_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 ) 10ba1d: 8b 43 2c mov 0x2c(%ebx),%eax <== NOT EXECUTED 10ba20: 85 c0 test %eax,%eax <== NOT EXECUTED 10ba22: 74 09 je 10ba2d <_User_extensions_Thread_exitted+0x20> <== NOT EXECUTED (*the_extension->Callouts.thread_exitted)( executing ); 10ba24: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ba27: 56 push %esi <== NOT EXECUTED 10ba28: ff d0 call *%eax <== NOT EXECUTED 10ba2a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 10ba2d: 8b 5b 04 mov 0x4(%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10ba30: 81 fb 18 cc 11 00 cmp $0x11cc18,%ebx <== NOT EXECUTED 10ba36: 75 e5 jne 10ba1d <_User_extensions_Thread_exitted+0x10> <== NOT EXECUTED the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) (*the_extension->Callouts.thread_exitted)( executing ); } } 10ba38: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ba3b: 5b pop %ebx <== NOT EXECUTED 10ba3c: 5e pop %esi <== NOT EXECUTED 10ba3d: c9 leave <== NOT EXECUTED 10ba3e: c3 ret <== NOT EXECUTED 0010c514 <_User_extensions_Thread_restart>: */ void _User_extensions_Thread_restart ( Thread_Control *the_thread ) { 10c514: 55 push %ebp <== NOT EXECUTED 10c515: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c517: 56 push %esi <== NOT EXECUTED 10c518: 53 push %ebx <== NOT EXECUTED 10c519: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; 10c51c: 8b 1d 84 fc 11 00 mov 0x11fc84,%ebx <== NOT EXECUTED 10c522: eb 17 jmp 10c53b <_User_extensions_Thread_restart+0x27> <== NOT EXECUTED !_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 ) 10c524: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10c527: 85 c0 test %eax,%eax <== NOT EXECUTED 10c529: 74 0e je 10c539 <_User_extensions_Thread_restart+0x25> <== NOT EXECUTED (*the_extension->Callouts.thread_restart)( 10c52b: 52 push %edx <== NOT EXECUTED 10c52c: 52 push %edx <== NOT EXECUTED 10c52d: 56 push %esi <== NOT EXECUTED 10c52e: ff 35 2c fb 11 00 pushl 0x11fb2c <== NOT EXECUTED 10c534: ff d0 call *%eax <== NOT EXECUTED 10c536: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10c539: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10c53b: 81 fb 88 fc 11 00 cmp $0x11fc88,%ebx <== NOT EXECUTED 10c541: 75 e1 jne 10c524 <_User_extensions_Thread_restart+0x10> <== NOT EXECUTED (*the_extension->Callouts.thread_restart)( _Thread_Executing, the_thread ); } } 10c543: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c546: 5b pop %ebx <== NOT EXECUTED 10c547: 5e pop %esi <== NOT EXECUTED 10c548: c9 leave <== NOT EXECUTED 10c549: c3 ret <== NOT EXECUTED 0010baf0 <_User_extensions_Thread_start>: */ void _User_extensions_Thread_start ( Thread_Control *the_thread ) { 10baf0: 55 push %ebp <== NOT EXECUTED 10baf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10baf3: 56 push %esi <== NOT EXECUTED 10baf4: 53 push %ebx <== NOT EXECUTED 10baf5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; 10baf8: 8b 1d 18 cc 11 00 mov 0x11cc18,%ebx <== NOT EXECUTED 10bafe: eb 17 jmp 10bb17 <_User_extensions_Thread_start+0x27> <== NOT EXECUTED !_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 ) 10bb00: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10bb03: 85 c0 test %eax,%eax <== NOT EXECUTED 10bb05: 74 0e je 10bb15 <_User_extensions_Thread_start+0x25> <== NOT EXECUTED (*the_extension->Callouts.thread_start)( 10bb07: 52 push %edx <== NOT EXECUTED 10bb08: 52 push %edx <== NOT EXECUTED 10bb09: 56 push %esi <== NOT EXECUTED 10bb0a: ff 35 c0 ca 11 00 pushl 0x11cac0 <== NOT EXECUTED 10bb10: ff d0 call *%eax <== NOT EXECUTED 10bb12: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10bb15: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10bb17: 81 fb 1c cc 11 00 cmp $0x11cc1c,%ebx <== NOT EXECUTED 10bb1d: 75 e1 jne 10bb00 <_User_extensions_Thread_start+0x10> <== NOT EXECUTED (*the_extension->Callouts.thread_start)( _Thread_Executing, the_thread ); } } 10bb1f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10bb22: 5b pop %ebx <== NOT EXECUTED 10bb23: 5e pop %esi <== NOT EXECUTED 10bb24: c9 leave <== NOT EXECUTED 10bb25: c3 ret <== NOT EXECUTED 0010bb28 <_User_extensions_Thread_switch>: */ void _User_extensions_Thread_switch ( Thread_Control *executing, Thread_Control *heir ) { 10bb28: 55 push %ebp <== NOT EXECUTED 10bb29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb2b: 57 push %edi <== NOT EXECUTED 10bb2c: 56 push %esi <== NOT EXECUTED 10bb2d: 53 push %ebx <== NOT EXECUTED 10bb2e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bb31: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10bb34: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _User_extensions_Switches_list.first ; 10bb37: 8b 1d 04 ca 11 00 mov 0x11ca04,%ebx <== NOT EXECUTED 10bb3d: eb 0c jmp 10bb4b <_User_extensions_Thread_switch+0x23> <== NOT EXECUTED !_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 ); 10bb3f: 50 push %eax <== NOT EXECUTED 10bb40: 50 push %eax <== NOT EXECUTED 10bb41: 56 push %esi <== NOT EXECUTED 10bb42: 57 push %edi <== NOT EXECUTED 10bb43: ff 53 08 call *0x8(%ebx) <== NOT EXECUTED Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _User_extensions_Switches_list.first ; !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; the_node = the_node->next ) { 10bb46: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED 10bb48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED { Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _User_extensions_Switches_list.first ; !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; 10bb4b: 81 fb 08 ca 11 00 cmp $0x11ca08,%ebx <== NOT EXECUTED 10bb51: 75 ec jne 10bb3f <_User_extensions_Thread_switch+0x17> <== NOT EXECUTED the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); } } 10bb53: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bb56: 5b pop %ebx <== NOT EXECUTED 10bb57: 5e pop %esi <== NOT EXECUTED 10bb58: 5f pop %edi <== NOT EXECUTED 10bb59: c9 leave <== NOT EXECUTED 10bb5a: c3 ret <== NOT EXECUTED 0010d194 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10d194: 55 push %ebp <== NOT EXECUTED 10d195: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d197: 57 push %edi <== NOT EXECUTED 10d198: 56 push %esi <== NOT EXECUTED 10d199: 53 push %ebx <== NOT EXECUTED 10d19a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d19d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10d1a0: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10d1a3: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10d1a6: 9c pushf <== NOT EXECUTED 10d1a7: fa cli <== NOT EXECUTED 10d1a8: 5a pop %edx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10d1a9: 8b 07 mov (%edi),%eax <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10d1ab: 8d 5f 04 lea 0x4(%edi),%ebx <== NOT EXECUTED 10d1ae: 89 5d f0 mov %ebx,-0x10(%ebp) <== NOT EXECUTED * hence the compiler must not assume *header to remain * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { 10d1b1: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10d1b3: 74 41 je 10d1f6 <_Watchdog_Adjust+0x62> <== NOT EXECUTED switch ( direction ) { 10d1b5: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10d1b7: 74 39 je 10d1f2 <_Watchdog_Adjust+0x5e> <== NOT EXECUTED 10d1b9: 49 dec %ecx <== NOT EXECUTED 10d1ba: 75 3a jne 10d1f6 <_Watchdog_Adjust+0x62> <== NOT EXECUTED case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10d1bc: 01 70 10 add %esi,0x10(%eax) <== NOT EXECUTED 10d1bf: eb 35 jmp 10d1f6 <_Watchdog_Adjust+0x62> <== NOT EXECUTED 10d1c1: 8b 07 mov (%edi),%eax <== NOT EXECUTED break; case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 10d1c3: 8b 58 10 mov 0x10(%eax),%ebx <== NOT EXECUTED 10d1c6: 39 de cmp %ebx,%esi <== NOT EXECUTED 10d1c8: 73 07 jae 10d1d1 <_Watchdog_Adjust+0x3d> <== NOT EXECUTED _Watchdog_First( header )->delta_interval -= units; 10d1ca: 29 f3 sub %esi,%ebx <== NOT EXECUTED 10d1cc: 89 58 10 mov %ebx,0x10(%eax) <== NOT EXECUTED 10d1cf: eb 25 jmp 10d1f6 <_Watchdog_Adjust+0x62> <== NOT EXECUTED break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 10d1d1: c7 40 10 01 00 00 00 movl $0x1,0x10(%eax) <== NOT EXECUTED _ISR_Enable( level ); 10d1d8: 52 push %edx <== NOT EXECUTED 10d1d9: 9d popf <== NOT EXECUTED _Watchdog_Tickle( header ); 10d1da: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d1dd: 57 push %edi <== NOT EXECUTED 10d1de: e8 9d 01 00 00 call 10d380 <_Watchdog_Tickle> <== NOT EXECUTED _ISR_Disable( level ); 10d1e3: 9c pushf <== NOT EXECUTED 10d1e4: fa cli <== NOT EXECUTED 10d1e5: 5a pop %edx <== NOT EXECUTED if ( _Chain_Is_empty( header ) ) 10d1e6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d1e9: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10d1ec: 39 07 cmp %eax,(%edi) <== NOT EXECUTED 10d1ee: 74 06 je 10d1f6 <_Watchdog_Adjust+0x62> <== NOT EXECUTED while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; 10d1f0: 29 de sub %ebx,%esi <== NOT EXECUTED switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10d1f2: 85 f6 test %esi,%esi <== NOT EXECUTED 10d1f4: 75 cb jne 10d1c1 <_Watchdog_Adjust+0x2d> <== NOT EXECUTED } break; } } _ISR_Enable( level ); 10d1f6: 52 push %edx <== NOT EXECUTED 10d1f7: 9d popf <== NOT EXECUTED } 10d1f8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d1fb: 5b pop %ebx <== NOT EXECUTED 10d1fc: 5e pop %esi <== NOT EXECUTED 10d1fd: 5f pop %edi <== NOT EXECUTED 10d1fe: c9 leave <== NOT EXECUTED 10d1ff: c3 ret <== NOT EXECUTED 00116778 <_Watchdog_Adjust_to_chain>: Chain_Control *header, Watchdog_Interval units_arg, Chain_Control *to_fire ) { 116778: 55 push %ebp <== NOT EXECUTED 116779: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11677b: 57 push %edi <== NOT EXECUTED 11677c: 56 push %esi <== NOT EXECUTED 11677d: 53 push %ebx <== NOT EXECUTED 11677e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 116781: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 116784: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED Watchdog_Interval units = units_arg; ISR_Level level; Chain_Node *node; if ( !units ) { 116787: 85 c0 test %eax,%eax <== NOT EXECUTED 116789: 74 74 je 1167ff <_Watchdog_Adjust_to_chain+0x87> <== NOT EXECUTED return; } _ISR_Disable( level ); 11678b: 9c pushf <== NOT EXECUTED 11678c: fa cli <== NOT EXECUTED 11678d: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 116790: 8d 7e 04 lea 0x4(%esi),%edi <== NOT EXECUTED if ( !_Chain_Is_empty( header ) ) { 116793: 39 3e cmp %edi,(%esi) <== NOT EXECUTED 116795: 74 64 je 1167fb <_Watchdog_Adjust_to_chain+0x83> <== NOT EXECUTED 116797: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 11679a: 83 c2 04 add $0x4,%edx <== NOT EXECUTED 11679d: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 1167a0: 89 c3 mov %eax,%ebx <== NOT EXECUTED 1167a2: 8b 06 mov (%esi),%eax <== NOT EXECUTED while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 1167a4: 8b 48 10 mov 0x10(%eax),%ecx <== NOT EXECUTED 1167a7: 39 cb cmp %ecx,%ebx <== NOT EXECUTED 1167a9: 73 07 jae 1167b2 <_Watchdog_Adjust_to_chain+0x3a> <== NOT EXECUTED _Watchdog_First( header )->delta_interval -= units; 1167ab: 29 d9 sub %ebx,%ecx <== NOT EXECUTED 1167ad: 89 48 10 mov %ecx,0x10(%eax) <== NOT EXECUTED 1167b0: eb 49 jmp 1167fb <_Watchdog_Adjust_to_chain+0x83> <== NOT EXECUTED break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 0; 1167b2: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 1167b9: 8b 16 mov (%esi),%edx <== NOT EXECUTED 1167bb: 39 fa cmp %edi,%edx <== NOT EXECUTED 1167bd: 75 04 jne 1167c3 <_Watchdog_Adjust_to_chain+0x4b> <== NOT EXECUTED 1167bf: 31 d2 xor %edx,%edx <== NOT EXECUTED 1167c1: eb 07 jmp 1167ca <_Watchdog_Adjust_to_chain+0x52> <== NOT EXECUTED 1167c3: 8b 02 mov (%edx),%eax <== NOT EXECUTED 1167c5: 89 06 mov %eax,(%esi) <== NOT EXECUTED 1167c7: 89 70 04 mov %esi,0x4(%eax) <== NOT EXECUTED 1167ca: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1167cd: 89 02 mov %eax,(%edx) <== NOT EXECUTED 1167cf: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1167d2: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 1167d5: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 1167d8: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1167db: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED 1167de: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1167e1: 89 10 mov %edx,(%eax) <== NOT EXECUTED 1167e3: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED do { node = _Chain_Get_unprotected( header ); _Chain_Append_unprotected( to_fire, node ); _ISR_Flash( level ); 1167e6: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 1167e9: 9d popf <== NOT EXECUTED 1167ea: fa cli <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 1167eb: 8b 06 mov (%esi),%eax <== NOT EXECUTED } while ( !_Chain_Is_empty( header ) && _Watchdog_First( header )->delta_interval == 0 ); 1167ed: 39 f8 cmp %edi,%eax <== NOT EXECUTED 1167ef: 74 0a je 1167fb <_Watchdog_Adjust_to_chain+0x83> <== NOT EXECUTED 1167f1: 83 78 10 00 cmpl $0x0,0x10(%eax) <== NOT EXECUTED 1167f5: 74 c2 je 1167b9 <_Watchdog_Adjust_to_chain+0x41> <== NOT EXECUTED return; } _ISR_Disable( level ); if ( !_Chain_Is_empty( header ) ) { while ( units ) { 1167f7: 29 cb sub %ecx,%ebx <== NOT EXECUTED 1167f9: 75 a7 jne 1167a2 <_Watchdog_Adjust_to_chain+0x2a> <== NOT EXECUTED break; } } } _ISR_Enable( level ); 1167fb: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 1167fe: 9d popf <== NOT EXECUTED } 1167ff: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 116802: 5b pop %ebx <== NOT EXECUTED 116803: 5e pop %esi <== NOT EXECUTED 116804: 5f pop %edi <== NOT EXECUTED 116805: c9 leave <== NOT EXECUTED 116806: c3 ret <== NOT EXECUTED 0010bc14 <_Watchdog_Handler_initialization>: * * Output parameters: NONE */ void _Watchdog_Handler_initialization( void ) { 10bc14: 55 push %ebp <== NOT EXECUTED 10bc15: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Watchdog_Sync_count = 0; 10bc17: c7 05 4c cb 11 00 00 movl $0x0,0x11cb4c <== NOT EXECUTED 10bc1e: 00 00 00 <== NOT EXECUTED _Watchdog_Sync_level = 0; 10bc21: c7 05 bc ca 11 00 00 movl $0x0,0x11cabc <== NOT EXECUTED 10bc28: 00 00 00 <== NOT EXECUTED _Watchdog_Ticks_since_boot = 0; 10bc2b: c7 05 50 cb 11 00 00 movl $0x0,0x11cb50 <== NOT EXECUTED 10bc32: 00 00 00 <== NOT EXECUTED 10bc35: c7 05 e0 ca 11 00 e4 movl $0x11cae4,0x11cae0 <== NOT EXECUTED 10bc3c: ca 11 00 <== NOT EXECUTED 10bc3f: c7 05 e4 ca 11 00 00 movl $0x0,0x11cae4 <== NOT EXECUTED 10bc46: 00 00 00 <== NOT EXECUTED 10bc49: c7 05 e8 ca 11 00 e0 movl $0x11cae0,0x11cae8 <== NOT EXECUTED 10bc50: ca 11 00 <== NOT EXECUTED 10bc53: c7 05 d4 ca 11 00 d8 movl $0x11cad8,0x11cad4 <== NOT EXECUTED 10bc5a: ca 11 00 <== NOT EXECUTED 10bc5d: c7 05 d8 ca 11 00 00 movl $0x0,0x11cad8 <== NOT EXECUTED 10bc64: 00 00 00 <== NOT EXECUTED 10bc67: c7 05 dc ca 11 00 d4 movl $0x11cad4,0x11cadc <== NOT EXECUTED 10bc6e: ca 11 00 <== NOT EXECUTED _Chain_Initialize_empty( &_Watchdog_Ticks_chain ); _Chain_Initialize_empty( &_Watchdog_Seconds_chain ); } 10bc71: c9 leave <== NOT EXECUTED 10bc72: c3 ret <== NOT EXECUTED 0010bb5c <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 10bb5c: 55 push %ebp <== NOT EXECUTED 10bb5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb5f: 57 push %edi <== NOT EXECUTED 10bb60: 56 push %esi <== NOT EXECUTED 10bb61: 53 push %ebx <== NOT EXECUTED 10bb62: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bb65: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Watchdog_Control *after; uint32_t insert_isr_nest_level; Watchdog_Interval delta_interval; insert_isr_nest_level = _ISR_Nest_level; 10bb68: 8b 3d 9c ca 11 00 mov 0x11ca9c,%edi <== NOT EXECUTED _ISR_Disable( level ); 10bb6e: 9c pushf <== NOT EXECUTED 10bb6f: fa cli <== NOT EXECUTED 10bb70: 8f 45 f0 popl -0x10(%ebp) <== NOT EXECUTED /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_watchdog->state != WATCHDOG_INACTIVE ) { 10bb73: 83 7e 08 00 cmpl $0x0,0x8(%esi) <== NOT EXECUTED 10bb77: 74 09 je 10bb82 <_Watchdog_Insert+0x26> <== NOT EXECUTED _ISR_Enable( level ); 10bb79: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10bb7c: 9d popf <== NOT EXECUTED 10bb7d: e9 89 00 00 00 jmp 10bc0b <_Watchdog_Insert+0xaf> <== NOT EXECUTED return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 10bb82: c7 46 08 01 00 00 00 movl $0x1,0x8(%esi) <== NOT EXECUTED _Watchdog_Sync_count++; 10bb89: a1 4c cb 11 00 mov 0x11cb4c,%eax <== NOT EXECUTED 10bb8e: 40 inc %eax <== NOT EXECUTED 10bb8f: a3 4c cb 11 00 mov %eax,0x11cb4c <== NOT EXECUTED restart: delta_interval = the_watchdog->initial; 10bb94: 8b 4e 0c mov 0xc(%esi),%ecx <== NOT EXECUTED * cache *header!! * * Till Straumann, 7/2003 (gcc-3.2.2 -O4 on powerpc) * */ for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ; 10bb97: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bb9a: 8b 18 mov (%eax),%ebx <== NOT EXECUTED ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10bb9c: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bb9e: 74 35 je 10bbd5 <_Watchdog_Insert+0x79> <== NOT EXECUTED 10bba0: 83 3b 00 cmpl $0x0,(%ebx) <== NOT EXECUTED 10bba3: 74 30 je 10bbd5 <_Watchdog_Insert+0x79> <== NOT EXECUTED break; if ( delta_interval < after->delta_interval ) { 10bba5: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED 10bba8: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 10bbaa: 73 07 jae 10bbb3 <_Watchdog_Insert+0x57> <== NOT EXECUTED after->delta_interval -= delta_interval; 10bbac: 29 ca sub %ecx,%edx <== NOT EXECUTED 10bbae: 89 53 10 mov %edx,0x10(%ebx) <== NOT EXECUTED 10bbb1: eb 22 jmp 10bbd5 <_Watchdog_Insert+0x79> <== NOT EXECUTED * used around this flash point allowed interrupts to execute * which violated the design assumptions. The critical section * mechanism used here WAS redesigned to address this. */ _ISR_Flash( level ); 10bbb3: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10bbb6: 9d popf <== NOT EXECUTED 10bbb7: fa cli <== NOT EXECUTED if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 10bbb8: 83 7e 08 01 cmpl $0x1,0x8(%esi) <== NOT EXECUTED 10bbbc: 75 38 jne 10bbf6 <_Watchdog_Insert+0x9a> <== NOT EXECUTED goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 10bbbe: a1 bc ca 11 00 mov 0x11cabc,%eax <== NOT EXECUTED 10bbc3: 39 f8 cmp %edi,%eax <== NOT EXECUTED 10bbc5: 76 08 jbe 10bbcf <_Watchdog_Insert+0x73> <== NOT EXECUTED _Watchdog_Sync_level = insert_isr_nest_level; 10bbc7: 89 3d bc ca 11 00 mov %edi,0x11cabc <== NOT EXECUTED 10bbcd: eb c5 jmp 10bb94 <_Watchdog_Insert+0x38> <== NOT EXECUTED if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; break; } delta_interval -= after->delta_interval; 10bbcf: 29 d1 sub %edx,%ecx <== NOT EXECUTED ); #ifdef __cplusplus } #endif 10bbd1: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED 10bbd3: eb c7 jmp 10bb9c <_Watchdog_Insert+0x40> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( 10bbd5: c7 46 08 02 00 00 00 movl $0x2,0x8(%esi) <== NOT EXECUTED } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 10bbdc: 89 4e 10 mov %ecx,0x10(%esi) <== NOT EXECUTED _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 10bbdf: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10bbe2: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 10bbe5: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10bbe7: 89 30 mov %esi,(%eax) <== NOT EXECUTED 10bbe9: 89 16 mov %edx,(%esi) <== NOT EXECUTED 10bbeb: 89 72 04 mov %esi,0x4(%edx) <== NOT EXECUTED the_watchdog->start_time = _Watchdog_Ticks_since_boot; 10bbee: a1 50 cb 11 00 mov 0x11cb50,%eax <== NOT EXECUTED 10bbf3: 89 46 14 mov %eax,0x14(%esi) <== NOT EXECUTED exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 10bbf6: 89 3d bc ca 11 00 mov %edi,0x11cabc <== NOT EXECUTED _Watchdog_Sync_count--; 10bbfc: a1 4c cb 11 00 mov 0x11cb4c,%eax <== NOT EXECUTED 10bc01: 48 dec %eax <== NOT EXECUTED 10bc02: a3 4c cb 11 00 mov %eax,0x11cb4c <== NOT EXECUTED _ISR_Enable( level ); 10bc07: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10bc0a: 9d popf <== NOT EXECUTED } 10bc0b: 58 pop %eax <== NOT EXECUTED 10bc0c: 5b pop %ebx <== NOT EXECUTED 10bc0d: 5e pop %esi <== NOT EXECUTED 10bc0e: 5f pop %edi <== NOT EXECUTED 10bc0f: c9 leave <== NOT EXECUTED 10bc10: c3 ret <== NOT EXECUTED 0010bc74 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10bc74: 55 push %ebp <== NOT EXECUTED 10bc75: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc77: 56 push %esi <== NOT EXECUTED 10bc78: 53 push %ebx <== NOT EXECUTED 10bc79: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10bc7c: 9c pushf <== NOT EXECUTED 10bc7d: fa cli <== NOT EXECUTED 10bc7e: 5e pop %esi <== NOT EXECUTED previous_state = the_watchdog->state; 10bc7f: 8b 59 08 mov 0x8(%ecx),%ebx <== NOT EXECUTED switch ( previous_state ) { 10bc82: 83 fb 01 cmp $0x1,%ebx <== NOT EXECUTED 10bc85: 74 09 je 10bc90 <_Watchdog_Remove+0x1c> <== NOT EXECUTED 10bc87: 72 41 jb 10bcca <_Watchdog_Remove+0x56> <== NOT EXECUTED 10bc89: 83 fb 03 cmp $0x3,%ebx <== NOT EXECUTED 10bc8c: 77 3c ja 10bcca <_Watchdog_Remove+0x56> <== NOT EXECUTED 10bc8e: eb 09 jmp 10bc99 <_Watchdog_Remove+0x25> <== NOT EXECUTED /* * 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; 10bc90: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED 10bc97: eb 31 jmp 10bcca <_Watchdog_Remove+0x56> <== NOT EXECUTED break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10bc99: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED ); #ifdef __cplusplus } #endif 10bca0: 8b 11 mov (%ecx),%edx <== NOT EXECUTED next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 10bca2: 83 3a 00 cmpl $0x0,(%edx) <== NOT EXECUTED 10bca5: 74 06 je 10bcad <_Watchdog_Remove+0x39> <== NOT EXECUTED next_watchdog->delta_interval += the_watchdog->delta_interval; 10bca7: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED 10bcaa: 01 42 10 add %eax,0x10(%edx) <== NOT EXECUTED if ( _Watchdog_Sync_count ) 10bcad: a1 4c cb 11 00 mov 0x11cb4c,%eax <== NOT EXECUTED 10bcb2: 85 c0 test %eax,%eax <== NOT EXECUTED 10bcb4: 74 0a je 10bcc0 <_Watchdog_Remove+0x4c> <== NOT EXECUTED _Watchdog_Sync_level = _ISR_Nest_level; 10bcb6: a1 9c ca 11 00 mov 0x11ca9c,%eax <== NOT EXECUTED 10bcbb: a3 bc ca 11 00 mov %eax,0x11cabc <== NOT EXECUTED 10bcc0: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10bcc2: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10bcc5: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10bcc8: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10bcca: a1 50 cb 11 00 mov 0x11cb50,%eax <== NOT EXECUTED 10bccf: 89 41 18 mov %eax,0x18(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10bcd2: 56 push %esi <== NOT EXECUTED 10bcd3: 9d popf <== NOT EXECUTED return( previous_state ); } 10bcd4: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bcd6: 5b pop %ebx <== NOT EXECUTED 10bcd7: 5e pop %esi <== NOT EXECUTED 10bcd8: c9 leave <== NOT EXECUTED 10bcd9: c3 ret <== NOT EXECUTED 0010bcdc <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 10bcdc: 55 push %ebp <== NOT EXECUTED 10bcdd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bcdf: 57 push %edi <== NOT EXECUTED 10bce0: 56 push %esi <== NOT EXECUTED 10bce1: 53 push %ebx <== NOT EXECUTED 10bce2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bce5: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED * 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 ); 10bce8: 9c pushf <== NOT EXECUTED 10bce9: fa cli <== NOT EXECUTED 10bcea: 5e pop %esi <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10bceb: 8b 17 mov (%edi),%edx <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10bced: 8d 47 04 lea 0x4(%edi),%eax <== NOT EXECUTED 10bcf0: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED if ( _Chain_Is_empty( header ) ) 10bcf3: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10bcf5: 74 44 je 10bd3b <_Watchdog_Tickle+0x5f> <== NOT EXECUTED 10bcf7: 89 d3 mov %edx,%ebx <== NOT EXECUTED * 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) { 10bcf9: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10bcfc: 85 c0 test %eax,%eax <== NOT EXECUTED 10bcfe: 74 08 je 10bd08 <_Watchdog_Tickle+0x2c> <== NOT EXECUTED the_watchdog->delta_interval--; 10bd00: 48 dec %eax <== NOT EXECUTED 10bd01: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED if ( the_watchdog->delta_interval != 0 ) 10bd04: 85 c0 test %eax,%eax <== NOT EXECUTED 10bd06: 75 33 jne 10bd3b <_Watchdog_Tickle+0x5f> <== NOT EXECUTED goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 10bd08: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bd0b: 53 push %ebx <== NOT EXECUTED 10bd0c: e8 63 ff ff ff call 10bc74 <_Watchdog_Remove> <== NOT EXECUTED _ISR_Enable( level ); 10bd11: 56 push %esi <== NOT EXECUTED 10bd12: 9d popf <== NOT EXECUTED switch( watchdog_state ) { 10bd13: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bd16: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10bd19: 75 0e jne 10bd29 <_Watchdog_Tickle+0x4d> <== NOT EXECUTED case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 10bd1b: 50 push %eax <== NOT EXECUTED 10bd1c: 50 push %eax <== NOT EXECUTED 10bd1d: ff 73 24 pushl 0x24(%ebx) <== NOT EXECUTED 10bd20: ff 73 20 pushl 0x20(%ebx) <== NOT EXECUTED 10bd23: ff 53 1c call *0x1c(%ebx) <== NOT EXECUTED 10bd26: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 10bd29: 9c pushf <== NOT EXECUTED 10bd2a: fa cli <== NOT EXECUTED 10bd2b: 5e pop %esi <== NOT EXECUTED 10bd2c: 8b 07 mov (%edi),%eax <== NOT EXECUTED the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 10bd2e: 3b 45 f0 cmp -0x10(%ebp),%eax <== NOT EXECUTED 10bd31: 74 08 je 10bd3b <_Watchdog_Tickle+0x5f> <== NOT EXECUTED 10bd33: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10bd35: 83 78 10 00 cmpl $0x0,0x10(%eax) <== NOT EXECUTED 10bd39: eb cb jmp 10bd06 <_Watchdog_Tickle+0x2a> <== NOT EXECUTED leave: _ISR_Enable(level); 10bd3b: 56 push %esi <== NOT EXECUTED 10bd3c: 9d popf <== NOT EXECUTED } 10bd3d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bd40: 5b pop %ebx <== NOT EXECUTED 10bd41: 5e pop %esi <== NOT EXECUTED 10bd42: 5f pop %edi <== NOT EXECUTED 10bd43: c9 leave <== NOT EXECUTED 10bd44: c3 ret <== NOT EXECUTED 0010bd5d <_Workspace_Allocate>: * _Workspace_Allocate */ void *_Workspace_Allocate( size_t size ) { 10bd5d: 55 push %ebp <== NOT EXECUTED 10bd5e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd60: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _Heap_Allocate( &_Workspace_Area, size ); 10bd63: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bd66: 68 24 ca 11 00 push $0x11ca24 <== NOT EXECUTED 10bd6b: e8 2c 1b 00 00 call 10d89c <_Heap_Allocate> <== NOT EXECUTED } 10bd70: c9 leave <== NOT EXECUTED 10bd71: c3 ret <== NOT EXECUTED 0010bd72 <_Workspace_Allocate_or_fatal_error>: * _Workspace_Allocate_or_fatal_error */ void *_Workspace_Allocate_or_fatal_error( size_t size ) { 10bd72: 55 push %ebp <== NOT EXECUTED 10bd73: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd75: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED */ void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 10bd78: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bd7b: 68 24 ca 11 00 push $0x11ca24 <== NOT EXECUTED 10bd80: e8 17 1b 00 00 call 10d89c <_Heap_Allocate> <== NOT EXECUTED { void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) 10bd85: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bd88: 85 c0 test %eax,%eax <== NOT EXECUTED 10bd8a: 75 0c jne 10bd98 <_Workspace_Allocate_or_fatal_error+0x26> <== NOT EXECUTED _Internal_error_Occurred( 10bd8c: 50 push %eax <== NOT EXECUTED 10bd8d: 6a 04 push $0x4 <== NOT EXECUTED 10bd8f: 6a 01 push $0x1 <== NOT EXECUTED 10bd91: 6a 00 push $0x0 <== NOT EXECUTED 10bd93: e8 90 e3 ff ff call 10a128 <_Internal_error_Occurred> <== NOT EXECUTED TRUE, INTERNAL_ERROR_WORKSPACE_ALLOCATION ); return memory; } 10bd98: c9 leave <== NOT EXECUTED 10bd99: c3 ret <== NOT EXECUTED 0010bd48 <_Workspace_Free>: * _Workspace_Free */ bool _Workspace_Free( void *block ) { 10bd48: 55 push %ebp <== NOT EXECUTED 10bd49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd4b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _Heap_Free( &_Workspace_Area, block ); 10bd4e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bd51: 68 24 ca 11 00 push $0x11ca24 <== NOT EXECUTED 10bd56: e8 ad 1b 00 00 call 10d908 <_Heap_Free> <== NOT EXECUTED } 10bd5b: c9 leave <== NOT EXECUTED 10bd5c: c3 ret <== NOT EXECUTED 0010bd9a <_Workspace_Handler_initialization>: */ void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 10bd9a: 55 push %ebp <== NOT EXECUTED 10bd9b: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd9d: 57 push %edi <== NOT EXECUTED 10bd9e: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10bda1: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) 10bda4: 85 d2 test %edx,%edx <== NOT EXECUTED 10bda6: 74 05 je 10bdad <_Workspace_Handler_initialization+0x13> <== NOT EXECUTED 10bda8: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 10bdab: 74 05 je 10bdb2 <_Workspace_Handler_initialization+0x18> <== NOT EXECUTED _Internal_error_Occurred( 10bdad: 51 push %ecx <== NOT EXECUTED 10bdae: 6a 02 push $0x2 <== NOT EXECUTED 10bdb0: eb 2e jmp 10bde0 <_Workspace_Handler_initialization+0x46> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _Configuration_Table->do_zero_of_workspace ) 10bdb2: a1 98 ca 11 00 mov 0x11ca98,%eax <== NOT EXECUTED 10bdb7: 80 78 28 00 cmpb $0x0,0x28(%eax) <== NOT EXECUTED 10bdbb: 74 09 je 10bdc6 <_Workspace_Handler_initialization+0x2c> <== NOT EXECUTED memset( starting_address, 0, size ); 10bdbd: 31 c0 xor %eax,%eax <== NOT EXECUTED 10bdbf: 89 d7 mov %edx,%edi <== NOT EXECUTED 10bdc1: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10bdc4: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED memory_available = _Heap_Initialize( 10bdc6: 6a 04 push $0x4 <== NOT EXECUTED 10bdc8: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10bdcb: 52 push %edx <== NOT EXECUTED 10bdcc: 68 24 ca 11 00 push $0x11ca24 <== NOT EXECUTED 10bdd1: e8 8a e1 ff ff call 109f60 <_Heap_Initialize> <== NOT EXECUTED starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 10bdd6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bdd9: 85 c0 test %eax,%eax <== NOT EXECUTED 10bddb: 75 0c jne 10bde9 <_Workspace_Handler_initialization+0x4f> <== NOT EXECUTED _Internal_error_Occurred( 10bddd: 52 push %edx <== NOT EXECUTED 10bdde: 6a 03 push $0x3 <== NOT EXECUTED 10bde0: 6a 01 push $0x1 <== NOT EXECUTED 10bde2: 6a 00 push $0x0 <== NOT EXECUTED 10bde4: e8 3f e3 ff ff call 10a128 <_Internal_error_Occurred> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); } 10bde9: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 10bdec: c9 leave <== NOT EXECUTED 10bded: c3 ret <== NOT EXECUTED 0010953c : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 10953c: 55 push %ebp <== NOT EXECUTED 10953d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10953f: 57 push %edi <== NOT EXECUTED 109540: 56 push %esi <== NOT EXECUTED 109541: 53 push %ebx <== NOT EXECUTED 109542: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 109545: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 109548: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10954b: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 10954e: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 109553: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 109557: 0f 84 90 00 00 00 je 1095ed <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 10955d: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 109562: 85 ff test %edi,%edi <== NOT EXECUTED 109564: 0f 84 83 00 00 00 je 1095ed <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 10956a: f7 c6 10 00 00 00 test $0x10,%esi <== NOT EXECUTED 109570: 74 12 je 109584 <== NOT EXECUTED the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 109572: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 109577: 85 d2 test %edx,%edx <== NOT EXECUTED 109579: 74 72 je 1095ed <== NOT EXECUTED if ( !id ) return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 10957b: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) <== NOT EXECUTED 109582: eb 07 jmp 10958b <== NOT EXECUTED if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; 109584: c7 45 ec 01 00 00 00 movl $0x1,-0x14(%ebp) <== NOT EXECUTED the_attributes.maximum_count = maximum_waiters; 10958b: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10958e: a1 f4 f4 11 00 mov 0x11f4f4,%eax <== NOT EXECUTED 109593: 40 inc %eax <== NOT EXECUTED 109594: a3 f4 f4 11 00 mov %eax,0x11f4f4 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 109599: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10959c: 68 fc f3 11 00 push $0x11f3fc <== NOT EXECUTED 1095a1: e8 c2 1a 00 00 call 10b068 <_Objects_Allocate> <== NOT EXECUTED 1095a6: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 1095a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1095ab: 85 c0 test %eax,%eax <== NOT EXECUTED 1095ad: 75 0c jne 1095bb <== NOT EXECUTED _Thread_Enable_dispatch(); 1095af: e8 b8 26 00 00 call 10bc6c <_Thread_Enable_dispatch> <== NOT EXECUTED 1095b4: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 1095b9: eb 32 jmp 1095ed <== NOT EXECUTED return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 1095bb: 89 70 10 mov %esi,0x10(%eax) <== NOT EXECUTED _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 1095be: 50 push %eax <== NOT EXECUTED 1095bf: 50 push %eax <== NOT EXECUTED 1095c0: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 1095c3: 50 push %eax <== NOT EXECUTED 1095c4: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 1095c7: 50 push %eax <== NOT EXECUTED 1095c8: e8 67 12 00 00 call 10a834 <_CORE_barrier_Initialize> <== NOT EXECUTED 1095cd: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 1095d0: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 1095d3: a1 18 f4 11 00 mov 0x11f418,%eax <== NOT EXECUTED 1095d8: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 1095db: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1095de: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 1095e1: 89 0f mov %ecx,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 1095e3: e8 84 26 00 00 call 10bc6c <_Thread_Enable_dispatch> <== NOT EXECUTED 1095e8: 31 c0 xor %eax,%eax <== NOT EXECUTED 1095ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 1095ed: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1095f0: 5b pop %ebx <== NOT EXECUTED 1095f1: 5e pop %esi <== NOT EXECUTED 1095f2: 5f pop %edi <== NOT EXECUTED 1095f3: c9 leave <== NOT EXECUTED 1095f4: c3 ret <== NOT EXECUTED 001095f8 : */ rtems_status_code rtems_barrier_delete( rtems_id id ) { 1095f8: 55 push %ebp <== NOT EXECUTED 1095f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1095fb: 53 push %ebx <== NOT EXECUTED 1095fc: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap 1095ff: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109602: 50 push %eax <== NOT EXECUTED 109603: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109606: 68 fc f3 11 00 push $0x11f3fc <== NOT EXECUTED 10960b: e8 9c 1e 00 00 call 10b4ac <_Objects_Get> <== NOT EXECUTED 109610: 89 c3 mov %eax,%ebx <== NOT EXECUTED Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 109612: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109615: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10961a: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10961e: 75 32 jne 109652 <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_barrier_Flush( 109620: 50 push %eax <== NOT EXECUTED 109621: 6a 02 push $0x2 <== NOT EXECUTED 109623: 6a 00 push $0x0 <== NOT EXECUTED 109625: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 109628: 50 push %eax <== NOT EXECUTED 109629: e8 9a 2c 00 00 call 10c2c8 <_Thread_queue_Flush> <== NOT EXECUTED &the_barrier->Barrier, NULL, CORE_BARRIER_WAS_DELETED ); _Objects_Close( &_Barrier_Information, &the_barrier->Object ); 10962e: 59 pop %ecx <== NOT EXECUTED 10962f: 58 pop %eax <== NOT EXECUTED 109630: 53 push %ebx <== NOT EXECUTED 109631: 68 fc f3 11 00 push $0x11f3fc <== NOT EXECUTED 109636: e8 a1 1a 00 00 call 10b0dc <_Objects_Close> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 10963b: 58 pop %eax <== NOT EXECUTED 10963c: 5a pop %edx <== NOT EXECUTED 10963d: 53 push %ebx <== NOT EXECUTED 10963e: 68 fc f3 11 00 push $0x11f3fc <== NOT EXECUTED 109643: e8 30 1d 00 00 call 10b378 <_Objects_Free> <== NOT EXECUTED _Barrier_Free( the_barrier ); _Thread_Enable_dispatch(); 109648: e8 1f 26 00 00 call 10bc6c <_Thread_Enable_dispatch> <== NOT EXECUTED 10964d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10964f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 109652: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109655: c9 leave <== NOT EXECUTED 109656: c3 ret <== NOT EXECUTED 00109658 : rtems_status_code rtems_barrier_ident( rtems_name name, rtems_id *id ) { 109658: 55 push %ebp <== NOT EXECUTED 109659: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10965b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 10965e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109661: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 109666: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109669: 68 fc f3 11 00 push $0x11f3fc <== NOT EXECUTED 10966e: e8 81 1f 00 00 call 10b5f4 <_Objects_Name_to_id_u32> <== NOT EXECUTED 109673: 8b 04 85 30 94 11 00 mov 0x119430(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 10967a: c9 leave <== NOT EXECUTED 10967b: c3 ret <== NOT EXECUTED 0010967c : rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) { 10967c: 55 push %ebp <== NOT EXECUTED 10967d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10967f: 56 push %esi <== NOT EXECUTED 109680: 53 push %ebx <== NOT EXECUTED 109681: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 109684: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 109687: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 10968a: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10968f: 85 f6 test %esi,%esi <== NOT EXECUTED 109691: 74 39 je 1096cc <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap 109693: 52 push %edx <== NOT EXECUTED 109694: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 109697: 50 push %eax <== NOT EXECUTED 109698: 53 push %ebx <== NOT EXECUTED 109699: 68 fc f3 11 00 push $0x11f3fc <== NOT EXECUTED 10969e: e8 09 1e 00 00 call 10b4ac <_Objects_Get> <== NOT EXECUTED 1096a3: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 1096a5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1096a8: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1096ad: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 1096b1: 75 19 jne 1096cc <== NOT EXECUTED case OBJECTS_LOCAL: *released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL ); 1096b3: 50 push %eax <== NOT EXECUTED 1096b4: 6a 00 push $0x0 <== NOT EXECUTED 1096b6: 53 push %ebx <== NOT EXECUTED 1096b7: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 1096ba: 50 push %eax <== NOT EXECUTED 1096bb: e8 a8 11 00 00 call 10a868 <_CORE_barrier_Release> <== NOT EXECUTED 1096c0: 89 06 mov %eax,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 1096c2: e8 a5 25 00 00 call 10bc6c <_Thread_Enable_dispatch> <== NOT EXECUTED 1096c7: 31 c0 xor %eax,%eax <== NOT EXECUTED 1096c9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1096cc: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1096cf: 5b pop %ebx <== NOT EXECUTED 1096d0: 5e pop %esi <== NOT EXECUTED 1096d1: c9 leave <== NOT EXECUTED 1096d2: c3 ret <== NOT EXECUTED 001096d4 : rtems_status_code rtems_barrier_wait( rtems_id id, rtems_interval timeout ) { 1096d4: 55 push %ebp <== NOT EXECUTED 1096d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1096d7: 53 push %ebx <== NOT EXECUTED 1096d8: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 1096db: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1096de: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1096e1: 50 push %eax <== NOT EXECUTED 1096e2: 53 push %ebx <== NOT EXECUTED 1096e3: 68 fc f3 11 00 push $0x11f3fc <== NOT EXECUTED 1096e8: e8 bf 1d 00 00 call 10b4ac <_Objects_Get> <== NOT EXECUTED 1096ed: 89 c2 mov %eax,%edx <== NOT EXECUTED Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 1096ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1096f2: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1096f7: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 1096fb: 75 2f jne 10972c <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_barrier_Wait( 1096fd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109700: 6a 00 push $0x0 <== NOT EXECUTED 109702: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109705: 6a 01 push $0x1 <== NOT EXECUTED 109707: 53 push %ebx <== NOT EXECUTED 109708: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 10970b: 50 push %eax <== NOT EXECUTED 10970c: e8 87 11 00 00 call 10a898 <_CORE_barrier_Wait> <== NOT EXECUTED id, TRUE, timeout, NULL ); _Thread_Enable_dispatch(); 109711: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109714: e8 53 25 00 00 call 10bc6c <_Thread_Enable_dispatch> <== NOT EXECUTED return _Barrier_Translate_core_barrier_return_code( 109719: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10971c: a1 b4 f5 11 00 mov 0x11f5b4,%eax <== NOT EXECUTED 109721: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 109724: e8 6b 4a 00 00 call 10e194 <_Barrier_Translate_core_barrier_return_code> <== NOT EXECUTED 109729: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10972c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10972f: c9 leave <== NOT EXECUTED 109730: c3 ret <== NOT EXECUTED 0010a318 : uint32_t api, uint32_t class, uint32_t node, uint32_t index ) { 10a318: 55 push %ebp <== NOT EXECUTED 10a319: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a31b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a31e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a321: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10a324: c1 e0 1b shl $0x1b,%eax <== NOT EXECUTED 10a327: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10a32a: 09 d0 or %edx,%eax <== NOT EXECUTED 10a32c: 0b 45 14 or 0x14(%ebp),%eax <== NOT EXECUTED 10a32f: c1 e1 10 shl $0x10,%ecx <== NOT EXECUTED 10a332: 09 c8 or %ecx,%eax <== NOT EXECUTED return _Objects_Build_id( api, class, node, index ); } 10a334: c9 leave <== NOT EXECUTED 10a335: c3 ret <== NOT EXECUTED 0010a338 : char C1, char C2, char C3, char C4 ) { 10a338: 55 push %ebp <== NOT EXECUTED 10a339: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a33b: 0f be 45 0c movsbl 0xc(%ebp),%eax <== NOT EXECUTED 10a33f: c1 e0 10 shl $0x10,%eax <== NOT EXECUTED 10a342: 0f be 55 08 movsbl 0x8(%ebp),%edx <== NOT EXECUTED 10a346: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10a349: 09 d0 or %edx,%eax <== NOT EXECUTED 10a34b: 0f be 55 10 movsbl 0x10(%ebp),%edx <== NOT EXECUTED 10a34f: c1 e2 08 shl $0x8,%edx <== NOT EXECUTED 10a352: 09 d0 or %edx,%eax <== NOT EXECUTED 10a354: 0f be 55 14 movsbl 0x14(%ebp),%edx <== NOT EXECUTED 10a358: 09 d0 or %edx,%eax <== NOT EXECUTED return _Objects_Build_name( C1, C2, C3, C4 ); } 10a35a: c9 leave <== NOT EXECUTED 10a35b: c3 ret <== NOT EXECUTED 00108958 : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 108958: 55 push %ebp <== NOT EXECUTED 108959: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10895b: 53 push %ebx <== NOT EXECUTED 10895c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10895f: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 108962: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED if ( !time_buffer ) 108965: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10896a: 85 db test %ebx,%ebx <== NOT EXECUTED 10896c: 74 44 je 1089b2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; switch ( option ) { 10896e: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 108973: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 108976: 77 3a ja 1089b2 <== NOT EXECUTED 108978: ff 24 95 a4 67 11 00 jmp *0x1167a4(,%edx,4) <== NOT EXECUTED case RTEMS_CLOCK_GET_TOD: return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 10897f: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 108982: 58 pop %eax <== NOT EXECUTED 108983: 5b pop %ebx <== NOT EXECUTED 108984: c9 leave <== NOT EXECUTED if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; switch ( option ) { case RTEMS_CLOCK_GET_TOD: return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 108985: e9 76 00 00 00 jmp 108a00 <== NOT EXECUTED case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH: return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); 10898a: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 10898d: 5b pop %ebx <== NOT EXECUTED 10898e: 5b pop %ebx <== NOT EXECUTED 10898f: c9 leave <== NOT EXECUTED switch ( option ) { case RTEMS_CLOCK_GET_TOD: return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH: return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); 108990: e9 23 00 00 00 jmp 1089b8 <== NOT EXECUTED case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_since_boot(); 108995: e8 5a 00 00 00 call 1089f4 <== NOT EXECUTED 10899a: eb 05 jmp 1089a1 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_TICKS_PER_SECOND: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_per_second(); 10899c: e8 3f 00 00 00 call 1089e0 <== NOT EXECUTED 1089a1: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 1089a3: 31 c0 xor %eax,%eax <== NOT EXECUTED 1089a5: eb 0b jmp 1089b2 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_TIME_VALUE: return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); 1089a7: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 1089aa: 59 pop %ecx <== NOT EXECUTED 1089ab: 5b pop %ebx <== NOT EXECUTED 1089ac: c9 leave <== NOT EXECUTED *interval = rtems_clock_get_ticks_per_second(); return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_TIME_VALUE: return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); 1089ad: e9 ea 00 00 00 jmp 108a9c <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 1089b2: 5a pop %edx <== NOT EXECUTED 1089b3: 5b pop %ebx <== NOT EXECUTED 1089b4: c9 leave <== NOT EXECUTED 1089b5: c3 ret <== NOT EXECUTED 001089b8 : #include rtems_status_code rtems_clock_get_seconds_since_epoch( rtems_interval *the_interval ) { 1089b8: 55 push %ebp <== NOT EXECUTED 1089b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1089bb: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !the_interval ) 1089be: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 1089c3: 85 d2 test %edx,%edx <== NOT EXECUTED 1089c5: 74 17 je 1089de <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 1089c7: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 1089cc: 80 3d 14 ca 11 00 00 cmpb $0x0,0x11ca14 <== NOT EXECUTED 1089d3: 74 09 je 1089de <== NOT EXECUTED return RTEMS_NOT_DEFINED; *the_interval = _TOD_Seconds_since_epoch; 1089d5: a1 90 ca 11 00 mov 0x11ca90,%eax <== NOT EXECUTED 1089da: 89 02 mov %eax,(%edx) <== NOT EXECUTED 1089dc: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 1089de: c9 leave <== NOT EXECUTED 1089df: c3 ret <== NOT EXECUTED 001089e0 : #include #include #include rtems_interval rtems_clock_get_ticks_per_second(void) { 1089e0: 55 push %ebp <== NOT EXECUTED 1089e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1089e3: b8 40 42 0f 00 mov $0xf4240,%eax <== NOT EXECUTED 1089e8: 31 d2 xor %edx,%edx <== NOT EXECUTED 1089ea: f7 35 9c cb 11 00 divl 0x11cb9c <== NOT EXECUTED return TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick; } 1089f0: c9 leave <== NOT EXECUTED 1089f1: c3 ret <== NOT EXECUTED 001089f4 : #include #include #include rtems_interval rtems_clock_get_ticks_since_boot(void) { 1089f4: 55 push %ebp <== NOT EXECUTED 1089f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Watchdog_Ticks_since_boot; 1089f7: a1 50 cb 11 00 mov 0x11cb50,%eax <== NOT EXECUTED } 1089fc: c9 leave <== NOT EXECUTED 1089fd: c3 ret <== NOT EXECUTED 00108a00 : #include rtems_status_code rtems_clock_get_tod( rtems_time_of_day *time_buffer ) { 108a00: 55 push %ebp <== NOT EXECUTED 108a01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108a03: 56 push %esi <== NOT EXECUTED 108a04: 53 push %ebx <== NOT EXECUTED 108a05: 83 ec 50 sub $0x50,%esp <== NOT EXECUTED 108a08: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED rtems_time_of_day *tmbuf = time_buffer; struct tm time; struct timeval now; if ( !time_buffer ) 108a0b: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 108a10: 85 f6 test %esi,%esi <== NOT EXECUTED 108a12: 74 7f je 108a93 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 108a14: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 108a19: 80 3d 14 ca 11 00 00 cmpb $0x0,0x11ca14 <== NOT EXECUTED 108a20: 74 71 je 108a93 <== NOT EXECUTED ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** 108a22: 9c pushf <== NOT EXECUTED 108a23: fa cli <== NOT EXECUTED 108a24: 5b pop %ebx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 108a25: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108a28: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 108a2b: 50 push %eax <== NOT EXECUTED 108a2c: e8 3f 14 00 00 call 109e70 <_TOD_Get> <== NOT EXECUTED * begin at @a starting_address. 108a31: 53 push %ebx <== NOT EXECUTED 108a32: 9d popf <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon 108a33: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 108a36: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory 108a39: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 108a3c: b9 e8 03 00 00 mov $0x3e8,%ecx <== NOT EXECUTED 108a41: 31 d2 xor %edx,%edx <== NOT EXECUTED 108a43: f7 f1 div %ecx <== NOT EXECUTED 108a45: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED /* Obtain the current time */ _TOD_Get_timeval( &now ); /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); 108a48: 58 pop %eax <== NOT EXECUTED 108a49: 5a pop %edx <== NOT EXECUTED 108a4a: 8d 45 c4 lea -0x3c(%ebp),%eax <== NOT EXECUTED 108a4d: 50 push %eax <== NOT EXECUTED 108a4e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 108a51: 50 push %eax <== NOT EXECUTED 108a52: e8 a1 63 00 00 call 10edf8 <== NOT EXECUTED /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; 108a57: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 108a5a: 05 6c 07 00 00 add $0x76c,%eax <== NOT EXECUTED 108a5f: 89 06 mov %eax,(%esi) <== NOT EXECUTED tmbuf->month = time.tm_mon + 1; 108a61: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 108a64: 40 inc %eax <== NOT EXECUTED 108a65: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED tmbuf->day = time.tm_mday; 108a68: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 108a6b: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED tmbuf->hour = time.tm_hour; 108a6e: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 108a71: 89 46 0c mov %eax,0xc(%esi) <== NOT EXECUTED tmbuf->minute = time.tm_min; 108a74: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 108a77: 89 46 10 mov %eax,0x10(%esi) <== NOT EXECUTED tmbuf->second = time.tm_sec; 108a7a: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED 108a7d: 89 46 14 mov %eax,0x14(%esi) <== NOT EXECUTED tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 108a80: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 108a83: 31 d2 xor %edx,%edx <== NOT EXECUTED 108a85: f7 35 9c cb 11 00 divl 0x11cb9c <== NOT EXECUTED 108a8b: 89 46 18 mov %eax,0x18(%esi) <== NOT EXECUTED 108a8e: 31 c0 xor %eax,%eax <== NOT EXECUTED 108a90: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 108a93: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108a96: 5b pop %ebx <== NOT EXECUTED 108a97: 5e pop %esi <== NOT EXECUTED 108a98: c9 leave <== NOT EXECUTED 108a99: c3 ret <== NOT EXECUTED 00108a9c : #include rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { 108a9c: 55 push %ebp <== NOT EXECUTED 108a9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108a9f: 56 push %esi <== NOT EXECUTED 108aa0: 53 push %ebx <== NOT EXECUTED 108aa1: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 108aa4: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED if ( !time ) 108aa7: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 108aac: 85 f6 test %esi,%esi <== NOT EXECUTED 108aae: 74 38 je 108ae8 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 108ab0: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 108ab5: 80 3d 14 ca 11 00 00 cmpb $0x0,0x11ca14 <== NOT EXECUTED 108abc: 74 2a je 108ae8 <== NOT EXECUTED ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** 108abe: 9c pushf <== NOT EXECUTED 108abf: fa cli <== NOT EXECUTED 108ac0: 5b pop %ebx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 108ac1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108ac4: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 108ac7: 50 push %eax <== NOT EXECUTED 108ac8: e8 a3 13 00 00 call 109e70 <_TOD_Get> <== NOT EXECUTED * begin at @a starting_address. 108acd: 53 push %ebx <== NOT EXECUTED 108ace: 9d popf <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon 108acf: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 108ad2: 89 06 mov %eax,(%esi) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory 108ad4: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 108ad7: b9 e8 03 00 00 mov $0x3e8,%ecx <== NOT EXECUTED 108adc: 31 d2 xor %edx,%edx <== NOT EXECUTED 108ade: f7 f1 div %ecx <== NOT EXECUTED 108ae0: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 108ae3: 31 c0 xor %eax,%eax <== NOT EXECUTED 108ae5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_NOT_DEFINED; _TOD_Get_timeval( time ); return RTEMS_SUCCESSFUL; } 108ae8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108aeb: 5b pop %ebx <== NOT EXECUTED 108aec: 5e pop %esi <== NOT EXECUTED 108aed: c9 leave <== NOT EXECUTED 108aee: c3 ret <== NOT EXECUTED 00108cf0 : * error code - if unsuccessful */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { 108cf0: 55 push %ebp <== NOT EXECUTED 108cf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108cf3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 108cf6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !uptime ) 108cf9: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 108cfe: 85 d2 test %edx,%edx <== NOT EXECUTED 108d00: 74 0e je 108d10 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime( uptime ); 108d02: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108d05: 52 push %edx <== NOT EXECUTED 108d06: e8 e5 14 00 00 call 10a1f0 <_TOD_Get_uptime> <== NOT EXECUTED 108d0b: 31 c0 xor %eax,%eax <== NOT EXECUTED 108d0d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 108d10: c9 leave <== NOT EXECUTED 108d11: c3 ret <== NOT EXECUTED 00109924 : */ rtems_status_code rtems_clock_set( rtems_time_of_day *time_buffer ) { 109924: 55 push %ebp <== NOT EXECUTED 109925: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109927: 53 push %ebx <== NOT EXECUTED 109928: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10992b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED struct timespec newtime; if ( !time_buffer ) 10992e: ba 09 00 00 00 mov $0x9,%edx <== NOT EXECUTED 109933: 85 db test %ebx,%ebx <== NOT EXECUTED 109935: 74 54 je 10998b <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( time_buffer ) ) { 109937: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10993a: 53 push %ebx <== NOT EXECUTED 10993b: e8 f8 00 00 00 call 109a38 <_TOD_Validate> <== NOT EXECUTED 109940: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109943: ba 14 00 00 00 mov $0x14,%edx <== NOT EXECUTED 109948: 84 c0 test %al,%al <== NOT EXECUTED 10994a: 74 3f je 10998b <== NOT EXECUTED newtime.tv_sec = _TOD_To_seconds( time_buffer ); 10994c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10994f: 53 push %ebx <== NOT EXECUTED 109950: e8 7b 00 00 00 call 1099d0 <_TOD_To_seconds> <== NOT EXECUTED 109955: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED newtime.tv_nsec = time_buffer->ticks * 109958: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10995b: 0f af 05 58 85 12 00 imul 0x128558,%eax <== NOT EXECUTED 109962: 69 c0 e8 03 00 00 imul $0x3e8,%eax,%eax <== NOT EXECUTED 109968: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10996b: a1 bc 83 12 00 mov 0x1283bc,%eax <== NOT EXECUTED 109970: 40 inc %eax <== NOT EXECUTED 109971: a3 bc 83 12 00 mov %eax,0x1283bc <== NOT EXECUTED (_TOD_Microseconds_per_tick * TOD_NANOSECONDS_PER_MICROSECOND); _Thread_Disable_dispatch(); _TOD_Set( &newtime ); 109976: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 109979: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10997c: e8 73 17 00 00 call 10b0f4 <_TOD_Set> <== NOT EXECUTED _Thread_Enable_dispatch(); 109981: e8 ba 27 00 00 call 10c140 <_Thread_Enable_dispatch> <== NOT EXECUTED 109986: 31 d2 xor %edx,%edx <== NOT EXECUTED 109988: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; } 10998b: 89 d0 mov %edx,%eax <== NOT EXECUTED 10998d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109990: c9 leave <== NOT EXECUTED 109991: c3 ret <== NOT EXECUTED 00108af0 : * error code - if unsuccessful */ rtems_status_code rtems_clock_set_nanoseconds_extension( rtems_nanoseconds_extension_routine routine ) { 108af0: 55 push %ebp <== NOT EXECUTED 108af1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108af3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !routine ) 108af6: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 108afb: 85 d2 test %edx,%edx <== NOT EXECUTED 108afd: 74 08 je 108b07 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _Watchdog_Nanoseconds_since_tick_handler = routine; 108aff: 89 15 a4 cb 11 00 mov %edx,0x11cba4 <== NOT EXECUTED 108b05: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 108b07: c9 leave <== NOT EXECUTED 108b08: c3 ret <== NOT EXECUTED 00108b0c : * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) { 108b0c: 55 push %ebp <== NOT EXECUTED 108b0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108b0f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED _TOD_Tickle_ticks(); 108b12: e8 e9 13 00 00 call 109f00 <_TOD_Tickle_ticks> <== NOT EXECUTED * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. * Any other value of @a alignment is taken "as is", i.e., even odd * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if 108b17: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108b1a: 68 e0 ca 11 00 push $0x11cae0 <== NOT EXECUTED 108b1f: e8 b8 31 00 00 call 10bcdc <_Watchdog_Tickle> <== NOT EXECUTED _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 108b24: e8 fb 2c 00 00 call 10b824 <_Thread_Tickle_timeslice> <== NOT EXECUTED 108b29: a0 d0 ca 11 00 mov 0x11cad0,%al <== NOT EXECUTED if ( _Thread_Is_context_switch_necessary() && 108b2e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108b31: 84 c0 test %al,%al <== NOT EXECUTED 108b33: 74 0e je 108b43 <== NOT EXECUTED 108b35: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 108b3a: 85 c0 test %eax,%eax <== NOT EXECUTED 108b3c: 75 05 jne 108b43 <== NOT EXECUTED _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 108b3e: e8 39 21 00 00 call 10ac7c <_Thread_Dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 108b43: 31 c0 xor %eax,%eax <== NOT EXECUTED 108b45: c9 leave <== NOT EXECUTED 108b46: c3 ret <== NOT EXECUTED 0010d5ed : */ void rtems_debug_disable ( rtems_debug_control to_be_disabled ) { 10d5ed: 55 push %ebp <== NOT EXECUTED 10d5ee: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d5f0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED _Debug_Level &= ~to_be_disabled; 10d5f3: f7 d0 not %eax <== NOT EXECUTED 10d5f5: 21 05 c4 ca 11 00 and %eax,0x11cac4 <== NOT EXECUTED } 10d5fb: c9 leave <== NOT EXECUTED 10d5fc: c3 ret <== NOT EXECUTED 0010d5df : */ void rtems_debug_enable ( rtems_debug_control to_be_enabled ) { 10d5df: 55 push %ebp <== NOT EXECUTED 10d5e0: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Debug_Level |= to_be_enabled; 10d5e2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d5e5: 09 05 c4 ca 11 00 or %eax,0x11cac4 <== NOT EXECUTED } 10d5eb: c9 leave <== NOT EXECUTED 10d5ec: c3 ret <== NOT EXECUTED 00108b48 : rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 108b48: 55 push %ebp <== NOT EXECUTED 108b49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108b4b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 108b4e: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 108b51: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED RTEMS_API_Control *api; if ( !event_out ) 108b54: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 108b59: 85 d2 test %edx,%edx <== NOT EXECUTED 108b5b: 74 3f je 108b9c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; 108b5d: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 108b62: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED if ( _Event_sets_Is_empty( event_in ) ) { 108b68: 85 c9 test %ecx,%ecx <== NOT EXECUTED 108b6a: 75 08 jne 108b74 <== NOT EXECUTED *event_out = api->pending_events; 108b6c: 8b 00 mov (%eax),%eax <== NOT EXECUTED 108b6e: 89 02 mov %eax,(%edx) <== NOT EXECUTED 108b70: 31 c0 xor %eax,%eax <== NOT EXECUTED 108b72: eb 28 jmp 108b9c <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 108b74: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 108b79: 40 inc %eax <== NOT EXECUTED 108b7a: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } _Thread_Disable_dispatch(); _Event_Seize( event_in, option_set, ticks, event_out ); 108b7f: 52 push %edx <== NOT EXECUTED 108b80: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 108b83: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 108b86: 51 push %ecx <== NOT EXECUTED 108b87: e8 14 00 00 00 call 108ba0 <_Event_Seize> <== NOT EXECUTED _Thread_Enable_dispatch(); 108b8c: e8 2f 22 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED return( _Thread_Executing->Wait.return_code ); 108b91: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 108b96: 8b 40 34 mov 0x34(%eax),%eax <== NOT EXECUTED 108b99: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 108b9c: c9 leave <== NOT EXECUTED 108b9d: c3 ret <== NOT EXECUTED 00108cb8 : rtems_status_code rtems_event_send( Objects_Id id, rtems_event_set event_in ) { 108cb8: 55 push %ebp <== NOT EXECUTED 108cb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108cbb: 53 push %ebx <== NOT EXECUTED 108cbc: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; the_thread = _Thread_Get( id, &location ); 108cbf: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 108cc2: 50 push %eax <== NOT EXECUTED 108cc3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 108cc6: e8 15 21 00 00 call 10ade0 <_Thread_Get> <== NOT EXECUTED 108ccb: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch ( location ) { 108ccd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108cd0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 108cd5: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 108cd9: 75 23 jne 108cfe <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 108cdb: 8b 83 f4 00 00 00 mov 0xf4(%ebx),%eax <== NOT EXECUTED * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, 108ce1: 9c pushf <== NOT EXECUTED 108ce2: fa cli <== NOT EXECUTED 108ce3: 59 pop %ecx <== NOT EXECUTED void *starting_address, 108ce4: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 108ce7: 09 10 or %edx,(%eax) <== NOT EXECUTED size_t size, 108ce9: 51 push %ecx <== NOT EXECUTED 108cea: 9d popf <== NOT EXECUTED _Event_sets_Post( event_in, &api->pending_events ); _Event_Surrender( the_thread ); 108ceb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108cee: 53 push %ebx <== NOT EXECUTED 108cef: e8 10 00 00 00 call 108d04 <_Event_Surrender> <== NOT EXECUTED _Thread_Enable_dispatch(); 108cf4: e8 c7 20 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 108cf9: 31 c0 xor %eax,%eax <== NOT EXECUTED 108cfb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 108cfe: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 108d01: c9 leave <== NOT EXECUTED 108d02: c3 ret <== NOT EXECUTED 0010ccd4 : rtems_status_code rtems_extension_create( rtems_name name, rtems_extensions_table *extension_table, Objects_Id *id ) { 10ccd4: 55 push %ebp <== NOT EXECUTED 10ccd5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ccd7: 57 push %edi <== NOT EXECUTED 10ccd8: 56 push %esi <== NOT EXECUTED 10ccd9: 53 push %ebx <== NOT EXECUTED 10ccda: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ccdd: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10cce0: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Extension_Control *the_extension; if ( !id ) 10cce3: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10cce8: 85 f6 test %esi,%esi <== NOT EXECUTED 10ccea: 74 61 je 10cd4d <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10ccec: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 10ccf1: 85 ff test %edi,%edi <== NOT EXECUTED 10ccf3: 74 58 je 10cd4d <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10ccf5: a1 84 88 12 00 mov 0x128884,%eax <== NOT EXECUTED 10ccfa: 40 inc %eax <== NOT EXECUTED 10ccfb: a3 84 88 12 00 mov %eax,0x128884 <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 10cd00: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cd03: 68 b4 8a 12 00 push $0x128ab4 <== NOT EXECUTED 10cd08: e8 2b 0b 00 00 call 10d838 <_Objects_Allocate> <== NOT EXECUTED 10cd0d: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 10cd0f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cd12: 85 c0 test %eax,%eax <== NOT EXECUTED 10cd14: 75 0c jne 10cd22 <== NOT EXECUTED _Thread_Enable_dispatch(); 10cd16: e8 21 17 00 00 call 10e43c <_Thread_Enable_dispatch> <== NOT EXECUTED 10cd1b: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10cd20: eb 2b jmp 10cd4d <== NOT EXECUTED return RTEMS_TOO_MANY; } _User_extensions_Add_set( &the_extension->Extension, extension_table ); 10cd22: 50 push %eax <== NOT EXECUTED 10cd23: 50 push %eax <== NOT EXECUTED 10cd24: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10cd27: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10cd2a: 50 push %eax <== NOT EXECUTED 10cd2b: e8 c8 22 00 00 call 10eff8 <_User_extensions_Add_set> <== NOT EXECUTED 10cd30: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10cd33: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10cd36: a1 d0 8a 12 00 mov 0x128ad0,%eax <== NOT EXECUTED 10cd3b: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10cd3e: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 10cd41: 89 0e mov %ecx,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10cd43: e8 f4 16 00 00 call 10e43c <_Thread_Enable_dispatch> <== NOT EXECUTED 10cd48: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cd4a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10cd4d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cd50: 5b pop %ebx <== NOT EXECUTED 10cd51: 5e pop %esi <== NOT EXECUTED 10cd52: 5f pop %edi <== NOT EXECUTED 10cd53: c9 leave <== NOT EXECUTED 10cd54: c3 ret <== NOT EXECUTED 0010cd58 : */ rtems_status_code rtems_extension_delete( Objects_Id id ) { 10cd58: 55 push %ebp <== NOT EXECUTED 10cd59: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cd5b: 53 push %ebx <== NOT EXECUTED 10cd5c: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure 10cd5f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10cd62: 50 push %eax <== NOT EXECUTED 10cd63: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cd66: 68 b4 8a 12 00 push $0x128ab4 <== NOT EXECUTED 10cd6b: e8 0c 0f 00 00 call 10dc7c <_Objects_Get> <== NOT EXECUTED 10cd70: 89 c3 mov %eax,%ebx <== NOT EXECUTED Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 10cd72: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cd75: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10cd7a: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10cd7e: 75 30 jne 10cdb0 <== NOT EXECUTED case OBJECTS_LOCAL: _User_extensions_Remove_set( &the_extension->Extension ); 10cd80: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cd83: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10cd86: 50 push %eax <== NOT EXECUTED 10cd87: e8 54 23 00 00 call 10f0e0 <_User_extensions_Remove_set> <== NOT EXECUTED _Objects_Close( &_Extension_Information, &the_extension->Object ); 10cd8c: 59 pop %ecx <== NOT EXECUTED 10cd8d: 58 pop %eax <== NOT EXECUTED 10cd8e: 53 push %ebx <== NOT EXECUTED 10cd8f: 68 b4 8a 12 00 push $0x128ab4 <== NOT EXECUTED 10cd94: e8 13 0b 00 00 call 10d8ac <_Objects_Close> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 10cd99: 58 pop %eax <== NOT EXECUTED 10cd9a: 5a pop %edx <== NOT EXECUTED 10cd9b: 53 push %ebx <== NOT EXECUTED 10cd9c: 68 b4 8a 12 00 push $0x128ab4 <== NOT EXECUTED 10cda1: e8 a2 0d 00 00 call 10db48 <_Objects_Free> <== NOT EXECUTED _Extension_Free( the_extension ); _Thread_Enable_dispatch(); 10cda6: e8 91 16 00 00 call 10e43c <_Thread_Enable_dispatch> <== NOT EXECUTED 10cdab: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cdad: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10cdb0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cdb3: c9 leave <== NOT EXECUTED 10cdb4: c3 ret <== NOT EXECUTED 0010afdc : rtems_status_code rtems_extension_ident( rtems_name name, Objects_Id *id ) { 10afdc: 55 push %ebp <== NOT EXECUTED 10afdd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10afdf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 10afe2: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10afe5: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 10afea: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10afed: 68 44 09 12 00 push $0x120944 <== NOT EXECUTED 10aff2: e8 15 10 00 00 call 10c00c <_Objects_Name_to_id_u32> <== NOT EXECUTED 10aff7: 8b 04 85 38 a7 11 00 mov 0x11a738(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 10affe: c9 leave <== NOT EXECUTED 10afff: c3 ret <== NOT EXECUTED 00109760 : */ void rtems_fatal_error_occurred( uint32_t the_error ) { 109760: 55 push %ebp <== NOT EXECUTED 109761: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109763: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, FALSE, the_error ); 109766: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109769: 6a 00 push $0x0 <== NOT EXECUTED 10976b: 6a 01 push $0x1 <== NOT EXECUTED 10976d: e8 b6 09 00 00 call 10a128 <_Internal_error_Occurred> <== NOT EXECUTED 0010adb0 : #endif #include const char *rtems_get_version_string(void) { 10adb0: 55 push %ebp <== NOT EXECUTED 10adb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _RTEMS_version; } 10adb3: b8 d8 bd 11 00 mov $0x11bdd8,%eax <== NOT EXECUTED 10adb8: c9 leave <== NOT EXECUTED 10adb9: c3 ret <== NOT EXECUTED 0010962c : * Scheduling can properly occur now as long as we avoid dispatching. */ } void rtems_initialize_before_drivers(void) { 10962c: 55 push %ebp <== NOT EXECUTED 10962d: 89 e5 mov %esp,%ebp <== NOT EXECUTED * Run the API and BSPs predriver hook. */ _API_extensions_Run_predriver(); } 10962f: c9 leave <== NOT EXECUTED /* * Run the API and BSPs predriver hook. */ _API_extensions_Run_predriver(); 109630: e9 82 02 00 00 jmp 1098b7 <_API_extensions_Run_predriver> <== NOT EXECUTED 00109635 : Objects_Information *_Internal_Objects[ OBJECTS_INTERNAL_CLASSES_LAST + 1 ]; void rtems_initialize_data_structures( rtems_configuration_table *configuration_table ) { 109635: 55 push %ebp <== NOT EXECUTED 109636: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109638: 53 push %ebx <== NOT EXECUTED 109639: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10963c: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* * Dispatching and interrupts are disabled until the end of the * initialization sequence. This prevents an inadvertent context * switch before the executive is initialized. */ _ISR_Disable( bsp_level ); 10963f: 9c pushf <== NOT EXECUTED 109640: fa cli <== NOT EXECUTED 109641: 58 pop %eax <== NOT EXECUTED /* * Make sure the parameters were not NULL. */ if ( configuration_table == NULL ) 109642: 85 db test %ebx,%ebx <== NOT EXECUTED 109644: 75 0c jne 109652 <== NOT EXECUTED _Internal_error_Occurred( 109646: 50 push %eax <== NOT EXECUTED 109647: 6a 00 push $0x0 <== NOT EXECUTED 109649: 6a 01 push $0x1 <== NOT EXECUTED 10964b: 6a 00 push $0x0 <== NOT EXECUTED 10964d: e8 d6 0a 00 00 call 10a128 <_Internal_error_Occurred> <== NOT EXECUTED ); /* * Provide pointers just for later convenience. */ _Configuration_Table = configuration_table; 109652: 89 1d 98 ca 11 00 mov %ebx,0x11ca98 <== NOT EXECUTED /* * Initialize any target architecture specific support as early as possible */ _CPU_Initialize( _Thread_Dispatch ); 109658: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10965b: 68 7c ac 10 00 push $0x10ac7c <== NOT EXECUTED 109660: e8 4b 29 00 00 call 10bfb0 <_CPU_Initialize> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** * This routine initializes @a the_heap record to manage the 109665: c7 05 a0 cb 11 00 00 movl $0x0,0x11cba0 <== NOT EXECUTED 10966c: 00 00 00 <== NOT EXECUTED /* * Do this as early as possible to insure no debugging output * is even attempted to be printed. */ _Debug_Manager_initialization(); 10966f: e8 5c 3f 00 00 call 10d5d0 <_Debug_Manager_initialization> <== NOT EXECUTED _API_extensions_Initialization(); 109674: e8 1b 02 00 00 call 109894 <_API_extensions_Initialization> <== NOT EXECUTED 109679: c7 05 00 ca 11 00 01 movl $0x1,0x11ca00 <== NOT EXECUTED 109680: 00 00 00 <== NOT EXECUTED /* * Before this is called, we are not allowed to allocate memory * from the Workspace because it is not initialized. */ _Workspace_Handler_initialization( 109683: 59 pop %ecx <== NOT EXECUTED 109684: 58 pop %eax <== NOT EXECUTED 109685: ff 73 04 pushl 0x4(%ebx) <== NOT EXECUTED 109688: ff 33 pushl (%ebx) <== NOT EXECUTED 10968a: e8 0b 27 00 00 call 10bd9a <_Workspace_Handler_initialization> <== NOT EXECUTED (void *)configuration_table->work_space_start, configuration_table->work_space_size ); _User_extensions_Handler_initialization( 10968f: 58 pop %eax <== NOT EXECUTED 109690: 5a pop %edx <== NOT EXECUTED 109691: ff 73 3c pushl 0x3c(%ebx) <== NOT EXECUTED 109694: ff 73 38 pushl 0x38(%ebx) <== NOT EXECUTED 109697: e8 b4 22 00 00 call 10b950 <_User_extensions_Handler_initialization> <== NOT EXECUTED configuration_table->number_of_initial_extensions, configuration_table->User_extension_table ); _ISR_Handler_initialization(); 10969c: e8 c7 0a 00 00 call 10a168 <_ISR_Handler_initialization> <== NOT EXECUTED _Objects_Handler_initialization( 1096a1: e8 0e 11 00 00 call 10a7b4 <_Objects_Handler_initialization> <== NOT EXECUTED _Configuration_MP_table->maximum_nodes, _Configuration_MP_table->maximum_global_objects #endif ); _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects; 1096a6: c7 05 d8 c9 11 00 18 movl $0x11ca18,0x11c9d8 <== NOT EXECUTED 1096ad: ca 11 00 <== NOT EXECUTED /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 1096b0: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED 1096b7: e8 14 03 00 00 call 1099d0 <_API_Mutex_Initialization> <== NOT EXECUTED _API_Mutex_Allocate( &_RTEMS_Allocator_Mutex ); 1096bc: c7 04 24 b8 ca 11 00 movl $0x11cab8,(%esp) <== NOT EXECUTED 1096c3: e8 88 02 00 00 call 109950 <_API_Mutex_Allocate> <== NOT EXECUTED #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of 1096c8: 66 c7 05 b4 ca 11 00 movw $0x0,0x11cab4 <== NOT EXECUTED 1096cf: 00 00 <== NOT EXECUTED 1096d1: 31 c0 xor %eax,%eax <== NOT EXECUTED 1096d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 1096d6: 66 c7 84 00 2c cb 11 movw $0x0,0x11cb2c(%eax,%eax,1) <== NOT EXECUTED 1096dd: 00 00 00 <== NOT EXECUTED /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of 1096e0: 40 inc %eax <== NOT EXECUTED 1096e1: 83 f8 10 cmp $0x10,%eax <== NOT EXECUTED 1096e4: 75 f0 jne 1096d6 <== NOT EXECUTED _Priority_Handler_initialization(); _Watchdog_Handler_initialization(); 1096e6: e8 29 25 00 00 call 10bc14 <_Watchdog_Handler_initialization> <== NOT EXECUTED _TOD_Handler_initialization( configuration_table->microseconds_per_tick ); 1096eb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1096ee: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 1096f1: e8 ce 07 00 00 call 109ec4 <_TOD_Handler_initialization> <== NOT EXECUTED _Thread_Handler_initialization( 1096f6: 5a pop %edx <== NOT EXECUTED 1096f7: 59 pop %ecx <== NOT EXECUTED 1096f8: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 1096fb: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1096fe: e8 29 19 00 00 call 10b02c <_Thread_Handler_initialization> <== NOT EXECUTED ); #endif /* MANAGERS */ _RTEMS_API_Initialize( configuration_table ); 109703: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 109706: e8 05 01 00 00 call 109810 <_RTEMS_API_Initialize> <== NOT EXECUTED _Extension_Manager_initialization( configuration_table->maximum_extensions ); 10970b: 58 pop %eax <== NOT EXECUTED 10970c: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10970f: e8 28 00 00 00 call 10973c <_Extension_Manager_initialization> <== NOT EXECUTED _IO_Manager_initialization( 109714: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 109717: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10971a: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10971d: ff 73 34 pushl 0x34(%ebx) <== NOT EXECUTED 109720: e8 76 00 00 00 call 10979b <_IO_Manager_initialization> <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 109725: c7 05 a0 cb 11 00 01 movl $0x1,0x11cba0 <== NOT EXECUTED 10972c: 00 00 00 <== NOT EXECUTED * * At this point all API extensions are in place. After the call to * _Thread_Create_idle() _Thread_Executing and _Thread_Heir will be set. */ _Thread_Create_idle(); 10972f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Scheduling can properly occur now as long as we avoid dispatching. */ } 109732: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109735: c9 leave <== NOT EXECUTED * * At this point all API extensions are in place. After the call to * _Thread_Create_idle() _Thread_Executing and _Thread_Heir will be set. */ _Thread_Create_idle(); 109736: e9 6d 14 00 00 jmp 10aba8 <_Thread_Create_idle> <== NOT EXECUTED 0010961b : _API_extensions_Run_predriver(); } void rtems_initialize_device_drivers(void) { 10961b: 55 push %ebp <== NOT EXECUTED 10961c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10961e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED * Initialize all the device drivers and initialize the MPCI layer. * * NOTE: The MPCI may be build upon a device driver. */ _IO_Initialize_all_drivers(); 109621: e8 4e 01 00 00 call 109774 <_IO_Initialize_all_drivers> <== NOT EXECUTED * * The API extensions are supposed to create user initialization tasks. */ _API_extensions_Run_postdriver(); } 109626: c9 leave <== NOT EXECUTED * Run the APIs and BSPs postdriver hooks. * * The API extensions are supposed to create user initialization tasks. */ _API_extensions_Run_postdriver(); 109627: e9 b1 02 00 00 jmp 1098dd <_API_extensions_Run_postdriver> <== NOT EXECUTED 00109608 : _API_extensions_Run_postdriver(); } void rtems_initialize_start_multitasking(void) { 109608: 55 push %ebp <== NOT EXECUTED 109609: 89 e5 mov %esp,%ebp <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 10960b: c7 05 a0 cb 11 00 02 movl $0x2,0x11cba0 <== NOT EXECUTED 109612: 00 00 00 <== NOT EXECUTED ****** APPLICATION RUNS HERE ****** ****** RETURNS WHEN SYSTEM IS SHUT DOWN ****** ******************************************************************* ******************************************************************* *******************************************************************/ } 109615: c9 leave <== NOT EXECUTED void rtems_initialize_start_multitasking(void) { _System_state_Set( SYSTEM_STATE_BEGIN_MULTITASKING ); _Thread_Start_multitasking(); 109616: e9 55 21 00 00 jmp 10b770 <_Thread_Start_multitasking> <== NOT EXECUTED 001094a4 : rtems_status_code rtems_interrupt_catch( rtems_isr_entry new_isr_handler, rtems_vector_number vector, rtems_isr_entry *old_isr_handler ) { 1094a4: 55 push %ebp <== NOT EXECUTED 1094a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1094a7: 53 push %ebx <== NOT EXECUTED 1094a8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1094ab: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1094ae: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 1094b1: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED if ( !_ISR_Is_vector_number_valid( vector ) ) 1094b4: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 1094b9: 81 fb ff 00 00 00 cmp $0xff,%ebx <== NOT EXECUTED 1094bf: 77 1d ja 1094de <== NOT EXECUTED return RTEMS_INVALID_NUMBER; if ( !_ISR_Is_valid_user_handler( (void *) new_isr_handler ) ) 1094c1: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1094c3: 74 14 je 1094d9 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_ISR_Is_valid_user_handler( (void *) old_isr_handler ) ) 1094c5: 85 d2 test %edx,%edx <== NOT EXECUTED 1094c7: 74 10 je 1094d9 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _ISR_Install_vector( 1094c9: 50 push %eax <== NOT EXECUTED 1094ca: 52 push %edx <== NOT EXECUTED 1094cb: 51 push %ecx <== NOT EXECUTED 1094cc: 53 push %ebx <== NOT EXECUTED 1094cd: e8 60 cc ff ff call 106132 <_CPU_ISR_install_vector> <== NOT EXECUTED 1094d2: 31 c0 xor %eax,%eax <== NOT EXECUTED 1094d4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1094d7: eb 05 jmp 1094de <== NOT EXECUTED vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler ); return RTEMS_SUCCESSFUL; 1094d9: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED } 1094de: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1094e1: c9 leave <== NOT EXECUTED 1094e2: c3 ret <== NOT EXECUTED 001099c0 : */ #undef rtems_interrupt_disable rtems_interrupt_level rtems_interrupt_disable( void ) { 1099c0: 55 push %ebp <== NOT EXECUTED 1099c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED rtems_interrupt_level previous_level; _ISR_Disable( previous_level ); 1099c3: 9c pushf <== NOT EXECUTED 1099c4: fa cli <== NOT EXECUTED 1099c5: 58 pop %eax <== NOT EXECUTED return previous_level; } 1099c6: c9 leave <== NOT EXECUTED 1099c7: c3 ret <== NOT EXECUTED 001099c8 : #undef rtems_interrupt_enable void rtems_interrupt_enable( rtems_interrupt_level previous_level ) { 1099c8: 55 push %ebp <== NOT EXECUTED 1099c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED _ISR_Enable( previous_level ); 1099cb: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1099ce: 9d popf <== NOT EXECUTED } 1099cf: c9 leave <== NOT EXECUTED 1099d0: c3 ret <== NOT EXECUTED 001099d1 : #undef rtems_interrupt_flash void rtems_interrupt_flash( rtems_interrupt_level previous_level ) { 1099d1: 55 push %ebp <== NOT EXECUTED 1099d2: 89 e5 mov %esp,%ebp <== NOT EXECUTED _ISR_Flash( previous_level ); 1099d4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1099d7: 9d popf <== NOT EXECUTED 1099d8: fa cli <== NOT EXECUTED } 1099d9: c9 leave <== NOT EXECUTED 1099da: c3 ret <== NOT EXECUTED 001099db : */ #undef rtems_interrupt_is_in_progress bool rtems_interrupt_is_in_progress( void ) { 1099db: 55 push %ebp <== NOT EXECUTED 1099dc: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _ISR_Is_in_progress(); 1099de: a1 50 f5 11 00 mov 0x11f550,%eax <== NOT EXECUTED 1099e3: 85 c0 test %eax,%eax <== NOT EXECUTED 1099e5: 0f 95 c0 setne %al <== NOT EXECUTED } 1099e8: c9 leave <== NOT EXECUTED 1099e9: c3 ret <== NOT EXECUTED 0010e3a8 : rtems_status_code rtems_io_close( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10e3a8: 55 push %ebp <== NOT EXECUTED 10e3a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e3ab: 56 push %esi <== NOT EXECUTED 10e3ac: 53 push %ebx <== NOT EXECUTED 10e3ad: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10e3b0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10e3b3: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10e3b6: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10e3bb: 3b 0d 2c cd 11 00 cmp 0x11cd2c,%ecx <== NOT EXECUTED 10e3c1: 73 20 jae 10e3e3 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; 10e3c3: 6b d1 18 imul $0x18,%ecx,%edx <== NOT EXECUTED 10e3c6: a1 30 cd 11 00 mov 0x11cd30,%eax <== NOT EXECUTED 10e3cb: 8b 54 02 08 mov 0x8(%edx,%eax,1),%edx <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e3cf: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e3d1: 85 d2 test %edx,%edx <== NOT EXECUTED 10e3d3: 74 0e je 10e3e3 <== NOT EXECUTED 10e3d5: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10e3d8: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10e3db: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10e3de: 5b pop %ebx <== NOT EXECUTED 10e3df: 5e pop %esi <== NOT EXECUTED 10e3e0: c9 leave <== NOT EXECUTED if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e3e1: ff e2 jmp *%edx <== NOT EXECUTED } 10e3e3: 5b pop %ebx <== NOT EXECUTED 10e3e4: 5e pop %esi <== NOT EXECUTED 10e3e5: c9 leave <== NOT EXECUTED 10e3e6: c3 ret <== NOT EXECUTED 0010e3e8 : rtems_status_code rtems_io_control( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10e3e8: 55 push %ebp <== NOT EXECUTED 10e3e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e3eb: 56 push %esi <== NOT EXECUTED 10e3ec: 53 push %ebx <== NOT EXECUTED 10e3ed: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10e3f0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10e3f3: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10e3f6: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10e3fb: 3b 0d 2c cd 11 00 cmp 0x11cd2c,%ecx <== NOT EXECUTED 10e401: 73 20 jae 10e423 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; 10e403: 6b d1 18 imul $0x18,%ecx,%edx <== NOT EXECUTED 10e406: a1 30 cd 11 00 mov 0x11cd30,%eax <== NOT EXECUTED 10e40b: 8b 54 02 14 mov 0x14(%edx,%eax,1),%edx <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e40f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e411: 85 d2 test %edx,%edx <== NOT EXECUTED 10e413: 74 0e je 10e423 <== NOT EXECUTED 10e415: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10e418: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10e41b: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10e41e: 5b pop %ebx <== NOT EXECUTED 10e41f: 5e pop %esi <== NOT EXECUTED 10e420: c9 leave <== NOT EXECUTED if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e421: ff e2 jmp *%edx <== NOT EXECUTED } 10e423: 5b pop %ebx <== NOT EXECUTED 10e424: 5e pop %esi <== NOT EXECUTED 10e425: c9 leave <== NOT EXECUTED 10e426: c3 ret <== NOT EXECUTED 0010d610 : rtems_status_code rtems_io_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10d610: 55 push %ebp <== NOT EXECUTED 10d611: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d613: 56 push %esi <== NOT EXECUTED 10d614: 53 push %ebx <== NOT EXECUTED 10d615: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10d618: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10d61b: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10d61e: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10d623: 3b 0d 2c cd 11 00 cmp 0x11cd2c,%ecx <== NOT EXECUTED 10d629: 73 1f jae 10d64a <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; 10d62b: 6b d1 18 imul $0x18,%ecx,%edx <== NOT EXECUTED 10d62e: a1 30 cd 11 00 mov 0x11cd30,%eax <== NOT EXECUTED 10d633: 8b 14 02 mov (%edx,%eax,1),%edx <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10d636: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d638: 85 d2 test %edx,%edx <== NOT EXECUTED 10d63a: 74 0e je 10d64a <== NOT EXECUTED 10d63c: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10d63f: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10d642: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10d645: 5b pop %ebx <== NOT EXECUTED 10d646: 5e pop %esi <== NOT EXECUTED 10d647: c9 leave <== NOT EXECUTED if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10d648: ff e2 jmp *%edx <== NOT EXECUTED } 10d64a: 5b pop %ebx <== NOT EXECUTED 10d64b: 5e pop %esi <== NOT EXECUTED 10d64c: c9 leave <== NOT EXECUTED 10d64d: c3 ret <== NOT EXECUTED 0010e428 : rtems_status_code rtems_io_open( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10e428: 55 push %ebp <== NOT EXECUTED 10e429: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e42b: 56 push %esi <== NOT EXECUTED 10e42c: 53 push %ebx <== NOT EXECUTED 10e42d: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10e430: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10e433: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10e436: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10e43b: 3b 0d 2c cd 11 00 cmp 0x11cd2c,%ecx <== NOT EXECUTED 10e441: 73 20 jae 10e463 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; 10e443: 6b d1 18 imul $0x18,%ecx,%edx <== NOT EXECUTED 10e446: a1 30 cd 11 00 mov 0x11cd30,%eax <== NOT EXECUTED 10e44b: 8b 54 02 04 mov 0x4(%edx,%eax,1),%edx <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e44f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e451: 85 d2 test %edx,%edx <== NOT EXECUTED 10e453: 74 0e je 10e463 <== NOT EXECUTED 10e455: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10e458: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10e45b: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10e45e: 5b pop %ebx <== NOT EXECUTED 10e45f: 5e pop %esi <== NOT EXECUTED 10e460: c9 leave <== NOT EXECUTED if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e461: ff e2 jmp *%edx <== NOT EXECUTED } 10e463: 5b pop %ebx <== NOT EXECUTED 10e464: 5e pop %esi <== NOT EXECUTED 10e465: c9 leave <== NOT EXECUTED 10e466: c3 ret <== NOT EXECUTED 0010e468 : rtems_status_code rtems_io_read( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10e468: 55 push %ebp <== NOT EXECUTED 10e469: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e46b: 56 push %esi <== NOT EXECUTED 10e46c: 53 push %ebx <== NOT EXECUTED 10e46d: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10e470: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10e473: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10e476: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10e47b: 3b 0d 2c cd 11 00 cmp 0x11cd2c,%ecx <== NOT EXECUTED 10e481: 73 20 jae 10e4a3 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; 10e483: 6b d1 18 imul $0x18,%ecx,%edx <== NOT EXECUTED 10e486: a1 30 cd 11 00 mov 0x11cd30,%eax <== NOT EXECUTED 10e48b: 8b 54 02 0c mov 0xc(%edx,%eax,1),%edx <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e48f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e491: 85 d2 test %edx,%edx <== NOT EXECUTED 10e493: 74 0e je 10e4a3 <== NOT EXECUTED 10e495: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10e498: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10e49b: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10e49e: 5b pop %ebx <== NOT EXECUTED 10e49f: 5e pop %esi <== NOT EXECUTED 10e4a0: c9 leave <== NOT EXECUTED if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e4a1: ff e2 jmp *%edx <== NOT EXECUTED } 10e4a3: 5b pop %ebx <== NOT EXECUTED 10e4a4: 5e pop %esi <== NOT EXECUTED 10e4a5: c9 leave <== NOT EXECUTED 10e4a6: c3 ret <== NOT EXECUTED 0010a4d8 : 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 ) { 10a4d8: 55 push %ebp <== NOT EXECUTED 10a4d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4db: 57 push %edi <== NOT EXECUTED 10a4dc: 56 push %esi <== NOT EXECUTED 10a4dd: 53 push %ebx <== NOT EXECUTED 10a4de: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a4e1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a4e4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10a4e7: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10a4ea: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 10a4ed: 85 f6 test %esi,%esi <== NOT EXECUTED 10a4ef: 0f 84 9a 00 00 00 je 10a58f <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 10a4f5: 85 c0 test %eax,%eax <== NOT EXECUTED 10a4f7: 0f 84 92 00 00 00 je 10a58f <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 10a4fd: 83 3e 00 cmpl $0x0,(%esi) <== NOT EXECUTED 10a500: 75 0a jne 10a50c <== NOT EXECUTED 10a502: 83 7e 04 00 cmpl $0x0,0x4(%esi) <== NOT EXECUTED 10a506: 0f 84 83 00 00 00 je 10a58f <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; *registered_major = 0; 10a50c: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10a50f: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 10a515: 8b 15 58 f7 11 00 mov 0x11f758,%edx <== NOT EXECUTED 10a51b: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10a520: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 10a522: 73 77 jae 10a59b <== NOT EXECUTED /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 10a524: 85 db test %ebx,%ebx <== NOT EXECUTED 10a526: 75 2b jne 10a553 <== NOT EXECUTED bool found = false; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 10a528: 8d 5a ff lea -0x1(%edx),%ebx <== NOT EXECUTED 10a52b: 6b c2 18 imul $0x18,%edx,%eax <== NOT EXECUTED 10a52e: 83 e8 18 sub $0x18,%eax <== NOT EXECUTED 10a531: 03 05 5c f7 11 00 add 0x11f75c,%eax <== NOT EXECUTED 10a537: eb 0f jmp 10a548 <== NOT EXECUTED if ( !_IO_Driver_address_table[major].initialization_entry && 10a539: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10a53c: 75 06 jne 10a544 <== NOT EXECUTED 10a53e: 83 78 04 00 cmpl $0x0,0x4(%eax) <== NOT EXECUTED 10a542: 74 0f je 10a553 <== NOT EXECUTED * in use. */ if ( major == 0 ) { bool found = false; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 10a544: 4b dec %ebx <== NOT EXECUTED 10a545: 83 e8 18 sub $0x18,%eax <== NOT EXECUTED 10a548: 85 db test %ebx,%ebx <== NOT EXECUTED 10a54a: 75 ed jne 10a539 <== NOT EXECUTED 10a54c: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10a551: eb 48 jmp 10a59b <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 10a553: 6b fb 18 imul $0x18,%ebx,%edi <== NOT EXECUTED 10a556: 03 3d 5c f7 11 00 add 0x11f75c,%edi <== NOT EXECUTED 10a55c: 83 3f 00 cmpl $0x0,(%edi) <== NOT EXECUTED 10a55f: 75 35 jne 10a596 <== NOT EXECUTED 10a561: 83 7f 04 00 cmpl $0x0,0x4(%edi) <== NOT EXECUTED 10a565: 75 2f jne 10a596 <== NOT EXECUTED _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 10a567: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10a56c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *registered_major = major; 10a56e: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10a571: 89 18 mov %ebx,(%eax) <== NOT EXECUTED return rtems_io_initialize( major, 0, NULL ); 10a573: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) <== NOT EXECUTED 10a57a: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) <== NOT EXECUTED 10a581: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 10a584: 5b pop %ebx <== NOT EXECUTED 10a585: 5e pop %esi <== NOT EXECUTED 10a586: 5b pop %ebx <== NOT EXECUTED 10a587: 5e pop %esi <== NOT EXECUTED 10a588: 5f pop %edi <== NOT EXECUTED 10a589: c9 leave <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10a58a: e9 ed fd ff ff jmp 10a37c <== NOT EXECUTED 10a58f: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a594: eb 05 jmp 10a59b <== NOT EXECUTED 10a596: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED } 10a59b: 5a pop %edx <== NOT EXECUTED 10a59c: 59 pop %ecx <== NOT EXECUTED 10a59d: 5b pop %ebx <== NOT EXECUTED 10a59e: 5e pop %esi <== NOT EXECUTED 10a59f: 5f pop %edi <== NOT EXECUTED 10a5a0: c9 leave <== NOT EXECUTED 10a5a1: c3 ret <== NOT EXECUTED 0010a5a4 : */ rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { 10a5a4: 55 push %ebp <== NOT EXECUTED 10a5a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a5a7: 57 push %edi <== NOT EXECUTED 10a5a8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a5ab: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( major < _IO_Number_of_drivers ) { 10a5ae: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 10a5b3: 3b 15 58 f7 11 00 cmp 0x11f758,%edx <== NOT EXECUTED 10a5b9: 73 12 jae 10a5cd <== NOT EXECUTED memset( 10a5bb: 6b fa 18 imul $0x18,%edx,%edi <== NOT EXECUTED 10a5be: 03 3d 5c f7 11 00 add 0x11f75c,%edi <== NOT EXECUTED 10a5c4: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10a5c9: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a5cb: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED sizeof( rtems_driver_address_table ) ); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 10a5cd: 5a pop %edx <== NOT EXECUTED 10a5ce: 5f pop %edi <== NOT EXECUTED 10a5cf: c9 leave <== NOT EXECUTED 10a5d0: c3 ret <== NOT EXECUTED 0010e4a8 : rtems_status_code rtems_io_write( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10e4a8: 55 push %ebp <== NOT EXECUTED 10e4a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e4ab: 56 push %esi <== NOT EXECUTED 10e4ac: 53 push %ebx <== NOT EXECUTED 10e4ad: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10e4b0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10e4b3: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10e4b6: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10e4bb: 3b 0d 2c cd 11 00 cmp 0x11cd2c,%ecx <== NOT EXECUTED 10e4c1: 73 20 jae 10e4e3 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; 10e4c3: 6b d1 18 imul $0x18,%ecx,%edx <== NOT EXECUTED 10e4c6: a1 30 cd 11 00 mov 0x11cd30,%eax <== NOT EXECUTED 10e4cb: 8b 54 02 10 mov 0x10(%edx,%eax,1),%edx <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e4cf: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e4d1: 85 d2 test %edx,%edx <== NOT EXECUTED 10e4d3: 74 0e je 10e4e3 <== NOT EXECUTED 10e4d5: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10e4d8: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10e4db: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10e4de: 5b pop %ebx <== NOT EXECUTED 10e4df: 5e pop %esi <== NOT EXECUTED 10e4e0: c9 leave <== NOT EXECUTED if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10e4e1: ff e2 jmp *%edx <== NOT EXECUTED } 10e4e3: 5b pop %ebx <== NOT EXECUTED 10e4e4: 5e pop %esi <== NOT EXECUTED 10e4e5: c9 leave <== NOT EXECUTED 10e4e6: c3 ret <== NOT EXECUTED 0010b40c : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10b40c: 55 push %ebp <== NOT EXECUTED 10b40d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b40f: 57 push %edi <== NOT EXECUTED 10b410: 56 push %esi <== NOT EXECUTED 10b411: 53 push %ebx <== NOT EXECUTED 10b412: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10b415: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 10b419: 74 41 je 10b45c <== NOT EXECUTED return; 10b41b: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 10b420: 8b 04 bd 90 83 12 00 mov 0x128390(,%edi,4),%eax <== NOT EXECUTED 10b427: 85 c0 test %eax,%eax <== NOT EXECUTED 10b429: 74 2b je 10b456 <== NOT EXECUTED continue; information = _Objects_Information_table[ api_index ][ 1 ]; 10b42b: 8b 70 04 mov 0x4(%eax),%esi <== NOT EXECUTED if ( information ) { 10b42e: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10b433: 85 f6 test %esi,%esi <== NOT EXECUTED 10b435: 75 17 jne 10b44e <== NOT EXECUTED 10b437: eb 1d jmp 10b456 <== NOT EXECUTED for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 10b439: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED 10b43c: 8b 04 98 mov (%eax,%ebx,4),%eax <== NOT EXECUTED if ( !the_thread ) 10b43f: 85 c0 test %eax,%eax <== NOT EXECUTED 10b441: 74 0a je 10b44d <== NOT EXECUTED continue; (*routine)(the_thread); 10b443: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b446: 50 push %eax <== NOT EXECUTED 10b447: ff 55 08 call *0x8(%ebp) <== NOT EXECUTED 10b44a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) continue; information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 10b44d: 43 inc %ebx <== NOT EXECUTED 10b44e: 0f b7 46 10 movzwl 0x10(%esi),%eax <== NOT EXECUTED 10b452: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10b454: 76 e3 jbe 10b439 <== NOT EXECUTED if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10b456: 47 inc %edi <== NOT EXECUTED if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 10b457: 83 ff 05 cmp $0x5,%edi <== NOT EXECUTED 10b45a: 75 c4 jne 10b420 <== NOT EXECUTED (*routine)(the_thread); } } } } 10b45c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b45f: 5b pop %ebx <== NOT EXECUTED 10b460: 5e pop %esi <== NOT EXECUTED 10b461: 5f pop %edi <== NOT EXECUTED 10b462: c9 leave <== NOT EXECUTED 10b463: c3 ret <== NOT EXECUTED 00110ca4 : Objects_Id id, const void *buffer, size_t size, uint32_t *count ) { 110ca4: 55 push %ebp <== NOT EXECUTED 110ca5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110ca7: 57 push %edi <== NOT EXECUTED 110ca8: 56 push %esi <== NOT EXECUTED 110ca9: 53 push %ebx <== NOT EXECUTED 110caa: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 110cad: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 110cb0: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 110cb3: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status core_status; if ( !buffer ) 110cb6: 85 ff test %edi,%edi <== NOT EXECUTED 110cb8: 74 4f je 110d09 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !count ) 110cba: 85 db test %ebx,%ebx <== NOT EXECUTED 110cbc: 74 4b je 110d09 <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 110cbe: 52 push %edx <== NOT EXECUTED 110cbf: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 110cc2: 50 push %eax <== NOT EXECUTED 110cc3: 56 push %esi <== NOT EXECUTED 110cc4: 68 94 2a 13 00 push $0x132a94 <== NOT EXECUTED 110cc9: e8 5e 42 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 110cce: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 110cd0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110cd3: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 110cd8: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 110cdc: 75 30 jne 110d0e <== NOT EXECUTED case OBJECTS_LOCAL: core_status = _CORE_message_queue_Broadcast( 110cde: 50 push %eax <== NOT EXECUTED 110cdf: 50 push %eax <== NOT EXECUTED 110ce0: 53 push %ebx <== NOT EXECUTED 110ce1: 6a 00 push $0x0 <== NOT EXECUTED 110ce3: 56 push %esi <== NOT EXECUTED 110ce4: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 110ce7: 57 push %edi <== NOT EXECUTED 110ce8: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 110ceb: 50 push %eax <== NOT EXECUTED 110cec: e8 4b 2d 00 00 call 113a3c <_CORE_message_queue_Broadcast> <== NOT EXECUTED 110cf1: 89 c3 mov %eax,%ebx <== NOT EXECUTED NULL, #endif count ); _Thread_Enable_dispatch(); 110cf3: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 110cf6: e8 f1 49 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED return 110cfb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110cfe: 53 push %ebx <== NOT EXECUTED 110cff: e8 00 03 00 00 call 111004 <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 110d04: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110d07: eb 05 jmp 110d0e <== NOT EXECUTED 110d09: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110d0e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 110d11: 5b pop %ebx <== NOT EXECUTED 110d12: 5e pop %esi <== NOT EXECUTED 110d13: 5f pop %edi <== NOT EXECUTED 110d14: c9 leave <== NOT EXECUTED 110d15: c3 ret <== NOT EXECUTED 0010d400 : uint32_t count, size_t max_message_size, rtems_attribute attribute_set, Objects_Id *id ) { 10d400: 55 push %ebp <== NOT EXECUTED 10d401: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d403: 57 push %edi <== NOT EXECUTED 10d404: 56 push %esi <== NOT EXECUTED 10d405: 53 push %ebx <== NOT EXECUTED 10d406: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10d409: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10d40c: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED CORE_message_queue_Attributes the_msgq_attributes; #if defined(RTEMS_MULTIPROCESSING) bool is_global; #endif if ( !rtems_is_name_valid( name ) ) 10d40f: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 10d414: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 10d418: 0f 84 b2 00 00 00 je 10d4d0 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 10d41e: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10d423: 83 7d 18 00 cmpl $0x0,0x18(%ebp) <== NOT EXECUTED 10d427: 0f 84 a3 00 00 00 je 10d4d0 <== NOT EXECUTED if ( (is_global = _Attributes_Is_global( attribute_set ) ) && !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) 10d42d: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10d432: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 10d436: 0f 84 94 00 00 00 je 10d4d0 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 10d43c: b8 08 00 00 00 mov $0x8,%eax <== NOT EXECUTED 10d441: 85 ff test %edi,%edi <== NOT EXECUTED 10d443: 0f 84 87 00 00 00 je 10d4d0 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10d449: a1 f4 9b 15 00 mov 0x159bf4,%eax <== NOT EXECUTED 10d44e: 40 inc %eax <== NOT EXECUTED 10d44f: a3 f4 9b 15 00 mov %eax,0x159bf4 <== NOT EXECUTED #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); 10d454: e8 5f 39 01 00 call 120db8 <_Message_queue_Allocate> <== NOT EXECUTED 10d459: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !the_message_queue ) { 10d45b: 85 c0 test %eax,%eax <== NOT EXECUTED 10d45d: 75 0c jne 10d46b <== NOT EXECUTED _Thread_Enable_dispatch(); 10d45f: e8 dc 24 00 00 call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 10d464: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10d469: eb 65 jmp 10d4d0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_message_queue->attribute_set = attribute_set; 10d46b: 89 70 10 mov %esi,0x10(%eax) <== NOT EXECUTED if (_Attributes_Is_priority( attribute_set ) ) the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 10d46e: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d470: f7 c6 04 00 00 00 test $0x4,%esi <== NOT EXECUTED 10d476: 0f 95 c0 setne %al <== NOT EXECUTED 10d479: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( ! _CORE_message_queue_Initialize( 10d47c: 57 push %edi <== NOT EXECUTED 10d47d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d480: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10d483: 50 push %eax <== NOT EXECUTED 10d484: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 10d487: 50 push %eax <== NOT EXECUTED 10d488: e8 8f 0d 00 00 call 10e21c <_CORE_message_queue_Initialize> <== NOT EXECUTED 10d48d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d490: 84 c0 test %al,%al <== NOT EXECUTED 10d492: 75 1c jne 10d4b0 <== NOT EXECUTED * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, 10d494: 50 push %eax <== NOT EXECUTED 10d495: 50 push %eax <== NOT EXECUTED 10d496: 53 push %ebx <== NOT EXECUTED 10d497: 68 cc 9f 15 00 push $0x159fcc <== NOT EXECUTED 10d49c: e8 23 1a 00 00 call 10eec4 <_Objects_Free> <== NOT EXECUTED _Objects_MP_Close( &_Message_queue_Information, the_message_queue->Object.id); #endif _Message_queue_Free( the_message_queue ); _Thread_Enable_dispatch(); 10d4a1: e8 9a 24 00 00 call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 10d4a6: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 10d4ab: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d4ae: eb 20 jmp 10d4d0 <== NOT EXECUTED 10d4b0: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10d4b3: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10d4b6: a1 e8 9f 15 00 mov 0x159fe8,%eax <== NOT EXECUTED 10d4bb: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10d4be: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d4c1: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 10d4c4: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10d4c7: 89 08 mov %ecx,(%eax) <== NOT EXECUTED name, 0 ); #endif _Thread_Enable_dispatch(); 10d4c9: e8 72 24 00 00 call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 10d4ce: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10d4d0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d4d3: 5b pop %ebx <== NOT EXECUTED 10d4d4: 5e pop %esi <== NOT EXECUTED 10d4d5: 5f pop %edi <== NOT EXECUTED 10d4d6: c9 leave <== NOT EXECUTED 10d4d7: c3 ret <== NOT EXECUTED 0011248c : */ rtems_status_code rtems_message_queue_delete( Objects_Id id ) { 11248c: 55 push %ebp <== NOT EXECUTED 11248d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11248f: 53 push %ebx <== NOT EXECUTED 112490: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 112493: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 112496: 50 push %eax <== NOT EXECUTED 112497: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11249a: 68 a8 8b 12 00 push $0x128ba8 <== NOT EXECUTED 11249f: e8 d8 b7 ff ff call 10dc7c <_Objects_Get> <== NOT EXECUTED 1124a4: 89 c3 mov %eax,%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 1124a6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1124a9: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1124ae: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 1124b2: 75 34 jne 1124e8 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, 1124b4: 51 push %ecx <== NOT EXECUTED 1124b5: 51 push %ecx <== NOT EXECUTED 1124b6: 53 push %ebx <== NOT EXECUTED 1124b7: 68 a8 8b 12 00 push $0x128ba8 <== NOT EXECUTED 1124bc: e8 eb b3 ff ff call 10d8ac <_Objects_Close> <== NOT EXECUTED &the_message_queue->Object ); _CORE_message_queue_Close( 1124c1: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1124c4: 6a 05 push $0x5 <== NOT EXECUTED 1124c6: 6a 00 push $0x0 <== NOT EXECUTED 1124c8: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 1124cb: 50 push %eax <== NOT EXECUTED 1124cc: e8 7b 04 00 00 call 11294c <_CORE_message_queue_Close> <== NOT EXECUTED * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, 1124d1: 58 pop %eax <== NOT EXECUTED 1124d2: 5a pop %edx <== NOT EXECUTED 1124d3: 53 push %ebx <== NOT EXECUTED 1124d4: 68 a8 8b 12 00 push $0x128ba8 <== NOT EXECUTED 1124d9: e8 6a b6 ff ff call 10db48 <_Objects_Free> <== NOT EXECUTED 0, /* Not used */ 0 ); } #endif _Thread_Enable_dispatch(); 1124de: e8 59 bf ff ff call 10e43c <_Thread_Enable_dispatch> <== NOT EXECUTED 1124e3: 31 c0 xor %eax,%eax <== NOT EXECUTED 1124e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1124e8: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1124eb: c9 leave <== NOT EXECUTED 1124ec: c3 ret <== NOT EXECUTED 00110e54 : rtems_status_code rtems_message_queue_flush( Objects_Id id, uint32_t *count ) { 110e54: 55 push %ebp <== NOT EXECUTED 110e55: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110e57: 53 push %ebx <== NOT EXECUTED 110e58: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 110e5b: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 110e5e: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 110e63: 85 db test %ebx,%ebx <== NOT EXECUTED 110e65: 74 3a je 110ea1 <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 110e67: 50 push %eax <== NOT EXECUTED 110e68: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 110e6b: 50 push %eax <== NOT EXECUTED 110e6c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 110e6f: 68 94 2a 13 00 push $0x132a94 <== NOT EXECUTED 110e74: e8 b3 40 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 110e79: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 110e7b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110e7e: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 110e83: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 110e87: 75 18 jne 110ea1 <== NOT EXECUTED case OBJECTS_LOCAL: *count = _CORE_message_queue_Flush( &the_message_queue->message_queue ); 110e89: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110e8c: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 110e8f: 50 push %eax <== NOT EXECUTED 110e90: e8 47 2c 00 00 call 113adc <_CORE_message_queue_Flush> <== NOT EXECUTED 110e95: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 110e97: e8 50 48 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 110e9c: 31 c0 xor %eax,%eax <== NOT EXECUTED 110e9e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110ea1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110ea4: c9 leave <== NOT EXECUTED 110ea5: c3 ret <== NOT EXECUTED 00110ea8 : rtems_status_code rtems_message_queue_get_number_pending( Objects_Id id, uint32_t *count ) { 110ea8: 55 push %ebp <== NOT EXECUTED 110ea9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110eab: 53 push %ebx <== NOT EXECUTED 110eac: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 110eaf: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 110eb2: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 110eb7: 85 db test %ebx,%ebx <== NOT EXECUTED 110eb9: 74 2e je 110ee9 <== NOT EXECUTED 110ebb: 50 push %eax <== NOT EXECUTED 110ebc: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 110ebf: 50 push %eax <== NOT EXECUTED 110ec0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 110ec3: 68 94 2a 13 00 push $0x132a94 <== NOT EXECUTED 110ec8: e8 5f 40 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 110ecd: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 110ecf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110ed2: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 110ed7: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 110edb: 75 0c jne 110ee9 <== NOT EXECUTED case OBJECTS_LOCAL: *count = the_message_queue->message_queue.number_of_pending_messages; 110edd: 8b 42 5c mov 0x5c(%edx),%eax <== NOT EXECUTED 110ee0: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 110ee2: e8 05 48 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 110ee7: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110ee9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110eec: c9 leave <== NOT EXECUTED 110eed: c3 ret <== NOT EXECUTED 00108e70 : rtems_status_code rtems_message_queue_ident( rtems_name name, uint32_t node, Objects_Id *id ) { 108e70: 55 push %ebp <== NOT EXECUTED 108e71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108e73: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 108e76: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 108e79: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 108e7c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 108e7f: 68 ac cc 11 00 push $0x11ccac <== NOT EXECUTED 108e84: e8 bf 18 00 00 call 10a748 <_Objects_Name_to_id_u32> <== NOT EXECUTED 108e89: 8b 04 85 34 68 11 00 mov 0x116834(,%eax,4),%eax <== NOT EXECUTED node, id ); return _Status_Object_name_errors_to_status[ status ]; } 108e90: c9 leave <== NOT EXECUTED 108e91: c3 ret <== NOT EXECUTED 001124f0 : void *buffer, size_t *size, rtems_option option_set, rtems_interval timeout ) { 1124f0: 55 push %ebp <== NOT EXECUTED 1124f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1124f3: 57 push %edi <== NOT EXECUTED 1124f4: 56 push %esi <== NOT EXECUTED 1124f5: 53 push %ebx <== NOT EXECUTED 1124f6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1124f9: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 1124fc: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 1124ff: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; bool wait; if ( !buffer ) 112502: 85 ff test %edi,%edi <== NOT EXECUTED 112504: 74 5d je 112563 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !size ) 112506: 85 f6 test %esi,%esi <== NOT EXECUTED 112508: 74 59 je 112563 <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 11250a: 52 push %edx <== NOT EXECUTED 11250b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 11250e: 50 push %eax <== NOT EXECUTED 11250f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112512: 68 a8 8b 12 00 push $0x128ba8 <== NOT EXECUTED 112517: e8 60 b7 ff ff call 10dc7c <_Objects_Get> <== NOT EXECUTED 11251c: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 11251e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112521: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112526: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 11252a: 75 3c jne 112568 <== NOT EXECUTED if ( _Options_Is_no_wait( option_set ) ) wait = false; else wait = true; _CORE_message_queue_Seize( 11252c: 50 push %eax <== NOT EXECUTED 11252d: 50 push %eax <== NOT EXECUTED 11252e: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 112531: 83 f3 01 xor $0x1,%ebx <== NOT EXECUTED 112534: 83 e3 01 and $0x1,%ebx <== NOT EXECUTED 112537: 53 push %ebx <== NOT EXECUTED 112538: 56 push %esi <== NOT EXECUTED 112539: 57 push %edi <== NOT EXECUTED 11253a: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED 11253d: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 112540: 50 push %eax <== NOT EXECUTED 112541: e8 56 05 00 00 call 112a9c <_CORE_message_queue_Seize> <== NOT EXECUTED buffer, size, wait, timeout ); _Thread_Enable_dispatch(); 112546: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 112549: e8 ee be ff ff call 10e43c <_Thread_Enable_dispatch> <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code( 11254e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112551: a1 44 89 12 00 mov 0x128944,%eax <== NOT EXECUTED 112556: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 112559: e8 66 9d ff ff call 10c2c4 <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 11255e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112561: eb 05 jmp 112568 <== NOT EXECUTED 112563: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112568: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11256b: 5b pop %ebx <== NOT EXECUTED 11256c: 5e pop %esi <== NOT EXECUTED 11256d: 5f pop %edi <== NOT EXECUTED 11256e: c9 leave <== NOT EXECUTED 11256f: c3 ret <== NOT EXECUTED 00108e94 : rtems_status_code rtems_message_queue_send( Objects_Id id, const void *buffer, size_t size ) { 108e94: 55 push %ebp <== NOT EXECUTED 108e95: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108e97: 56 push %esi <== NOT EXECUTED 108e98: 53 push %ebx <== NOT EXECUTED 108e99: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 108e9c: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 108e9f: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 108ea2: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 108ea7: 85 f6 test %esi,%esi <== NOT EXECUTED 108ea9: 74 4f je 108efa <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 108eab: 50 push %eax <== NOT EXECUTED 108eac: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 108eaf: 50 push %eax <== NOT EXECUTED 108eb0: 53 push %ebx <== NOT EXECUTED 108eb1: 68 ac cc 11 00 push $0x11ccac <== NOT EXECUTED 108eb6: e8 45 17 00 00 call 10a600 <_Objects_Get> <== NOT EXECUTED 108ebb: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 108ebd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108ec0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 108ec5: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 108ec9: 75 2f jne 108efa <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 108ecb: 6a 00 push $0x0 <== NOT EXECUTED 108ecd: 6a 00 push $0x0 <== NOT EXECUTED 108ecf: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 108ed4: 6a 00 push $0x0 <== NOT EXECUTED 108ed6: 53 push %ebx <== NOT EXECUTED 108ed7: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 108eda: 56 push %esi <== NOT EXECUTED 108edb: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 108ede: 50 push %eax <== NOT EXECUTED 108edf: e8 88 0b 00 00 call 109a6c <_CORE_message_queue_Submit> <== NOT EXECUTED 108ee4: 89 c3 mov %eax,%ebx <== NOT EXECUTED MESSAGE_QUEUE_MP_HANDLER, FALSE, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 108ee6: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 108ee9: e8 d2 1e 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED /* * Since this API does not allow for blocking sends, we can directly * return the returned status. */ return _Message_queue_Translate_core_message_queue_return_code(status); 108eee: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108ef1: 53 push %ebx <== NOT EXECUTED 108ef2: e8 0d 00 00 00 call 108f04 <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 108ef7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 108efa: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108efd: 5b pop %ebx <== NOT EXECUTED 108efe: 5e pop %esi <== NOT EXECUTED 108eff: c9 leave <== NOT EXECUTED 108f00: c3 ret <== NOT EXECUTED 00111014 : rtems_status_code rtems_message_queue_urgent( Objects_Id id, const void *buffer, size_t size ) { 111014: 55 push %ebp <== NOT EXECUTED 111015: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111017: 56 push %esi <== NOT EXECUTED 111018: 53 push %ebx <== NOT EXECUTED 111019: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 11101c: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 11101f: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 111022: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 111027: 85 f6 test %esi,%esi <== NOT EXECUTED 111029: 74 4f je 11107a <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 11102b: 50 push %eax <== NOT EXECUTED 11102c: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 11102f: 50 push %eax <== NOT EXECUTED 111030: 53 push %ebx <== NOT EXECUTED 111031: 68 94 2a 13 00 push $0x132a94 <== NOT EXECUTED 111036: e8 f1 3e 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 11103b: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 11103d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111040: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 111045: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 111049: 75 2f jne 11107a <== NOT EXECUTED size_t size 11104b: 6a 00 push $0x0 <== NOT EXECUTED 11104d: 6a 00 push $0x0 <== NOT EXECUTED 11104f: 68 00 00 00 80 push $0x80000000 <== NOT EXECUTED 111054: 6a 00 push $0x0 <== NOT EXECUTED 111056: 53 push %ebx <== NOT EXECUTED 111057: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 11105a: 56 push %esi <== NOT EXECUTED 11105b: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 11105e: 50 push %eax <== NOT EXECUTED 11105f: e8 cc 2c 00 00 call 113d30 <_CORE_message_queue_Submit> <== NOT EXECUTED 111064: 89 c3 mov %eax,%ebx <== NOT EXECUTED id, MESSAGE_QUEUE_MP_HANDLER, FALSE, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 111066: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 111069: e8 7e 46 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED /* * Since this API does not allow for blocking sends, we can directly * return the returned status. */ return _Message_queue_Translate_core_message_queue_return_code(status); 11106e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111071: 53 push %ebx <== NOT EXECUTED 111072: e8 8d ff ff ff call 111004 <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 111077: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11107a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11107d: 5b pop %ebx <== NOT EXECUTED 11107e: 5e pop %esi <== NOT EXECUTED 11107f: c9 leave <== NOT EXECUTED 111080: c3 ret <== NOT EXECUTED 0010a35c : #include int rtems_object_api_maximum_class( uint32_t api ) { 10a35c: 55 push %ebp <== NOT EXECUTED 10a35d: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_API_maximum_class(api); } 10a35f: c9 leave <== NOT EXECUTED int rtems_object_api_maximum_class( uint32_t api ) { return _Objects_API_maximum_class(api); 10a360: e9 13 15 00 00 jmp 10b878 <_Objects_API_maximum_class> <== NOT EXECUTED 0010a368 : #include uint32_t rtems_object_api_minimum_class( uint32_t api ) { 10a368: 55 push %ebp <== NOT EXECUTED 10a369: 89 e5 mov %esp,%ebp <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10a36b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a36e: 48 dec %eax <== NOT EXECUTED 10a36f: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10a372: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10a374: 83 e0 02 and $0x2,%eax <== NOT EXECUTED 10a377: 48 dec %eax <== NOT EXECUTED if ( _Objects_Is_api_valid( api ) ) return 1; return -1; } 10a378: c9 leave <== NOT EXECUTED 10a379: c3 ret <== NOT EXECUTED 0010a37c : const char *rtems_object_get_api_class_name( uint32_t the_api, uint32_t the_class ) { 10a37c: 55 push %ebp <== NOT EXECUTED 10a37d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a37f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a382: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) 10a385: b8 c8 e3 11 00 mov $0x11e3c8,%eax <== NOT EXECUTED 10a38a: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 10a38d: 74 0f je 10a39e <== NOT EXECUTED api_assoc = rtems_object_api_internal_assoc; else if ( the_api == OBJECTS_CLASSIC_API ) 10a38f: b8 04 a5 11 00 mov $0x11a504,%eax <== NOT EXECUTED 10a394: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 10a397: 75 20 jne 10a3b9 <== NOT EXECUTED 10a399: b8 e0 e3 11 00 mov $0x11e3e0,%eax <== NOT EXECUTED else if ( the_api == OBJECTS_ITRON_API ) api_assoc = rtems_object_api_itron_assoc; #endif else return "BAD API"; class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class ); 10a39e: 52 push %edx <== NOT EXECUTED 10a39f: 52 push %edx <== NOT EXECUTED 10a3a0: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a3a3: 50 push %eax <== NOT EXECUTED 10a3a4: e8 33 40 00 00 call 10e3dc <== NOT EXECUTED 10a3a9: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( class_assoc ) 10a3ab: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a3ae: b8 0c a5 11 00 mov $0x11a50c,%eax <== NOT EXECUTED 10a3b3: 85 d2 test %edx,%edx <== NOT EXECUTED 10a3b5: 74 02 je 10a3b9 <== NOT EXECUTED return class_assoc->name; 10a3b7: 8b 02 mov (%edx),%eax <== NOT EXECUTED return "BAD CLASS"; } 10a3b9: c9 leave <== NOT EXECUTED 10a3ba: c3 ret <== NOT EXECUTED 0010a3bc : }; const char *rtems_object_get_api_name( uint32_t api ) { 10a3bc: 55 push %ebp <== NOT EXECUTED 10a3bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a3bf: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED const rtems_assoc_t *api_assoc; api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api ); 10a3c2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a3c5: 68 58 e4 11 00 push $0x11e458 <== NOT EXECUTED 10a3ca: e8 0d 40 00 00 call 10e3dc <== NOT EXECUTED 10a3cf: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( api_assoc ) 10a3d1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a3d4: b8 0c a5 11 00 mov $0x11a50c,%eax <== NOT EXECUTED 10a3d9: 85 d2 test %edx,%edx <== NOT EXECUTED 10a3db: 74 02 je 10a3df <== NOT EXECUTED return api_assoc->name; 10a3dd: 8b 02 mov (%edx),%eax <== NOT EXECUTED return "BAD CLASS"; } 10a3df: c9 leave <== NOT EXECUTED 10a3e0: c3 ret <== NOT EXECUTED 0010a41c : rtems_status_code rtems_object_get_class_information( uint32_t the_api, uint32_t the_class, rtems_object_api_class_information *info ) { 10a41c: 55 push %ebp <== NOT EXECUTED 10a41d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a41f: 57 push %edi <== NOT EXECUTED 10a420: 56 push %esi <== NOT EXECUTED 10a421: 53 push %ebx <== NOT EXECUTED 10a422: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a425: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED uint32_t i; /* * Validate parameters and look up information structure. */ if ( !info ) 10a428: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a42d: 85 ff test %edi,%edi <== NOT EXECUTED 10a42f: 74 50 je 10a481 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); 10a431: 50 push %eax <== NOT EXECUTED 10a432: 50 push %eax <== NOT EXECUTED 10a433: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a436: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a439: e8 9a 17 00 00 call 10bbd8 <_Objects_Get_information> <== NOT EXECUTED 10a43e: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !obj_info ) 10a440: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a443: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10a448: 85 db test %ebx,%ebx <== NOT EXECUTED 10a44a: 74 35 je 10a481 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 10a44c: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10a44f: 89 07 mov %eax,(%edi) <== NOT EXECUTED info->maximum_id = obj_info->maximum_id; 10a451: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10a454: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED info->auto_extend = obj_info->auto_extend; 10a457: 8a 43 12 mov 0x12(%ebx),%al <== NOT EXECUTED 10a45a: 88 47 0c mov %al,0xc(%edi) <== NOT EXECUTED info->maximum = obj_info->maximum; 10a45d: 0f b7 73 10 movzwl 0x10(%ebx),%esi <== NOT EXECUTED 10a461: 89 77 08 mov %esi,0x8(%edi) <== NOT EXECUTED 10a464: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10a466: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10a46b: eb 0b jmp 10a478 <== NOT EXECUTED for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) if ( !obj_info->local_table[i] ) 10a46d: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED unallocated++; 10a470: 83 3c 90 01 cmpl $0x1,(%eax,%edx,4) <== NOT EXECUTED 10a474: 83 d1 00 adc $0x0,%ecx <== NOT EXECUTED 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++ ) 10a477: 42 inc %edx <== NOT EXECUTED 10a478: 39 f2 cmp %esi,%edx <== NOT EXECUTED 10a47a: 76 f1 jbe 10a46d <== NOT EXECUTED if ( !obj_info->local_table[i] ) unallocated++; info->unallocated = unallocated; 10a47c: 89 4f 10 mov %ecx,0x10(%edi) <== NOT EXECUTED 10a47f: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10a481: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a484: 5b pop %ebx <== NOT EXECUTED 10a485: 5e pop %esi <== NOT EXECUTED 10a486: 5f pop %edi <== NOT EXECUTED 10a487: c9 leave <== NOT EXECUTED 10a488: c3 ret <== NOT EXECUTED 00109d28 : rtems_status_code rtems_object_get_classic_name( rtems_id id, rtems_name *name ) { 109d28: 55 push %ebp <== NOT EXECUTED 109d29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109d2b: 53 push %ebx <== NOT EXECUTED 109d2c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 109d2f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; Objects_Name name_u; if ( !name ) 109d32: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 109d37: 85 db test %ebx,%ebx <== NOT EXECUTED 109d39: 74 1d je 109d58 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; status = _Objects_Id_to_name( id, &name_u ); 109d3b: 50 push %eax <== NOT EXECUTED 109d3c: 50 push %eax <== NOT EXECUTED 109d3d: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109d40: 50 push %eax <== NOT EXECUTED 109d41: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109d44: e8 57 18 00 00 call 10b5a0 <_Objects_Id_to_name> <== NOT EXECUTED *name = name_u.name_u32; 109d49: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 109d4c: 89 13 mov %edx,(%ebx) <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; 109d4e: 8b 04 85 0c 96 11 00 mov 0x11960c(,%eax,4),%eax <== NOT EXECUTED 109d55: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109d58: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109d5b: c9 leave <== NOT EXECUTED 109d5c: c3 ret <== NOT EXECUTED 001125e4 : char *rtems_object_get_name( Objects_Id id, size_t length, char *name ) { 1125e4: 55 push %ebp <== NOT EXECUTED 1125e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_Get_name_as_string( id, length, name ); } 1125e7: c9 leave <== NOT EXECUTED Objects_Id id, size_t length, char *name ) { return _Objects_Get_name_as_string( id, length, name ); 1125e8: e9 2b 09 00 00 jmp 112f18 <_Objects_Get_name_as_string> <== NOT EXECUTED 0010a498 : #include #include #undef rtems_object_id_api_maximum uint32_t rtems_object_id_api_maximum(void) { 10a498: 55 push %ebp <== NOT EXECUTED 10a499: 89 e5 mov %esp,%ebp <== NOT EXECUTED return OBJECTS_ITRON_API; } 10a49b: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10a4a0: c9 leave <== NOT EXECUTED 10a4a1: c3 ret <== NOT EXECUTED 0010a4a4 : #include #include #undef rtems_object_id_api_minimum uint32_t rtems_object_id_api_minimum(void) { 10a4a4: 55 push %ebp <== NOT EXECUTED 10a4a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED return OBJECTS_INTERNAL_API; } 10a4a7: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10a4ac: c9 leave <== NOT EXECUTED 10a4ad: c3 ret <== NOT EXECUTED 0010a4b0 : #undef rtems_object_id_get_api uint32_t rtems_object_id_get_api( rtems_id id ) { 10a4b0: 55 push %ebp <== NOT EXECUTED 10a4b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4b3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a4b6: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10a4b9: 83 e0 07 and $0x7,%eax <== NOT EXECUTED return _Objects_Get_API( id ); } 10a4bc: c9 leave <== NOT EXECUTED 10a4bd: c3 ret <== NOT EXECUTED 0010a4c0 : #undef rtems_object_id_get_class uint32_t rtems_object_id_get_class( rtems_id id ) { 10a4c0: 55 push %ebp <== NOT EXECUTED 10a4c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4c3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a4c6: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED return _Objects_Get_class( id ); } 10a4c9: c9 leave <== NOT EXECUTED 10a4ca: c3 ret <== NOT EXECUTED 0010a4cc : #undef rtems_object_id_get_index uint32_t rtems_object_id_get_index( rtems_id id ) { 10a4cc: 55 push %ebp <== NOT EXECUTED 10a4cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4cf: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED return _Objects_Get_index( id ); } 10a4d3: c9 leave <== NOT EXECUTED 10a4d4: c3 ret <== NOT EXECUTED 0010a4d8 : #undef rtems_object_id_get_node uint32_t rtems_object_id_get_node( rtems_id id ) { 10a4d8: 55 push %ebp <== NOT EXECUTED 10a4d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4db: 0f b6 45 0a movzbl 0xa(%ebp),%eax <== NOT EXECUTED return _Objects_Get_node( id ); } 10a4df: c9 leave <== NOT EXECUTED 10a4e0: c3 ret <== NOT EXECUTED 0010a4e4 : */ rtems_status_code rtems_object_set_name( rtems_id id, const char *name ) { 10a4e4: 55 push %ebp <== NOT EXECUTED 10a4e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4e7: 57 push %edi <== NOT EXECUTED 10a4e8: 56 push %esi <== NOT EXECUTED 10a4e9: 53 push %ebx <== NOT EXECUTED 10a4ea: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10a4ed: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 10a4f0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a4f5: 85 ff test %edi,%edi <== NOT EXECUTED 10a4f7: 74 50 je 10a549 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10a4f9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a4fc: 85 db test %ebx,%ebx <== NOT EXECUTED 10a4fe: 75 08 jne 10a508 <== NOT EXECUTED 10a500: a1 2c 06 12 00 mov 0x12062c,%eax <== NOT EXECUTED 10a505: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 10a508: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a50b: 53 push %ebx <== NOT EXECUTED 10a50c: e8 a7 16 00 00 call 10bbb8 <_Objects_Get_information_id> <== NOT EXECUTED 10a511: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( !information ) 10a513: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a516: 85 c0 test %eax,%eax <== NOT EXECUTED 10a518: 74 2a je 10a544 <== NOT EXECUTED return RTEMS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &location ); 10a51a: 51 push %ecx <== NOT EXECUTED 10a51b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10a51e: 50 push %eax <== NOT EXECUTED 10a51f: 53 push %ebx <== NOT EXECUTED 10a520: 56 push %esi <== NOT EXECUTED 10a521: e8 2a 18 00 00 call 10bd50 <_Objects_Get> <== NOT EXECUTED switch ( location ) { 10a526: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a529: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 10a52d: 75 15 jne 10a544 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Set_name( information, the_object, name ); 10a52f: 52 push %edx <== NOT EXECUTED 10a530: 57 push %edi <== NOT EXECUTED 10a531: 50 push %eax <== NOT EXECUTED 10a532: 56 push %esi <== NOT EXECUTED 10a533: e8 54 1a 00 00 call 10bf8c <_Objects_Set_name> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a538: e8 33 21 00 00 call 10c670 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a53d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a53f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a542: eb 05 jmp 10a549 <== NOT EXECUTED return RTEMS_SUCCESSFUL; 10a544: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a549: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a54c: 5b pop %ebx <== NOT EXECUTED 10a54d: 5e pop %esi <== NOT EXECUTED 10a54e: 5f pop %edi <== NOT EXECUTED 10a54f: c9 leave <== NOT EXECUTED 10a550: c3 ret <== NOT EXECUTED 00111084 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, Objects_Id *id ) { 111084: 55 push %ebp <== NOT EXECUTED 111085: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111087: 57 push %edi <== NOT EXECUTED 111088: 56 push %esi <== NOT EXECUTED 111089: 53 push %ebx <== NOT EXECUTED 11108a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11108d: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 111090: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 111093: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 111098: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 11109c: 0f 84 c9 00 00 00 je 11116b <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !starting_address ) 1110a2: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 1110a6: 0f 84 b3 00 00 00 je 11115f <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !id ) 1110ac: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp) <== NOT EXECUTED 1110b0: 0f 84 a9 00 00 00 je 11115f <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 1110b6: 85 ff test %edi,%edi <== NOT EXECUTED 1110b8: 0f 84 a8 00 00 00 je 111166 <== NOT EXECUTED 1110be: 85 f6 test %esi,%esi <== NOT EXECUTED 1110c0: 0f 84 a0 00 00 00 je 111166 <== NOT EXECUTED 1110c6: 39 f7 cmp %esi,%edi <== NOT EXECUTED 1110c8: 0f 82 98 00 00 00 jb 111166 <== NOT EXECUTED 1110ce: f7 c6 03 00 00 00 test $0x3,%esi <== NOT EXECUTED 1110d4: 0f 85 8c 00 00 00 jne 111166 <== NOT EXECUTED !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 1110da: f6 45 0c 03 testb $0x3,0xc(%ebp) <== NOT EXECUTED 1110de: 75 7f jne 11115f <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1110e0: a1 e0 27 13 00 mov 0x1327e0,%eax <== NOT EXECUTED 1110e5: 40 inc %eax <== NOT EXECUTED 1110e6: a3 e0 27 13 00 mov %eax,0x1327e0 <== NOT EXECUTED * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of 1110eb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1110ee: 68 14 26 13 00 push $0x132614 <== NOT EXECUTED 1110f3: e8 b4 39 00 00 call 114aac <_Objects_Allocate> <== NOT EXECUTED 1110f8: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 1110fa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1110fd: 85 c0 test %eax,%eax <== NOT EXECUTED 1110ff: 75 0c jne 11110d <== NOT EXECUTED _Thread_Enable_dispatch(); 111101: e8 e6 45 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 111106: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 11110b: eb 5e jmp 11116b <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 11110d: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 111110: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED the_partition->length = length; 111113: 89 7b 14 mov %edi,0x14(%ebx) <== NOT EXECUTED the_partition->buffer_size = buffer_size; 111116: 89 73 18 mov %esi,0x18(%ebx) <== NOT EXECUTED the_partition->attribute_set = attribute_set; 111119: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 11111c: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED the_partition->number_of_used_blocks = 0; 11111f: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED _Chain_Initialize( &the_partition->Memory, starting_address, 111126: 56 push %esi <== NOT EXECUTED 111127: 89 f8 mov %edi,%eax <== NOT EXECUTED 111129: 31 d2 xor %edx,%edx <== NOT EXECUTED 11112b: f7 f6 div %esi <== NOT EXECUTED 11112d: 50 push %eax <== NOT EXECUTED 11112e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111131: 8d 43 24 lea 0x24(%ebx),%eax <== NOT EXECUTED 111134: 50 push %eax <== NOT EXECUTED 111135: e8 ca 28 00 00 call 113a04 <_Chain_Initialize> <== NOT EXECUTED 11113a: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 11113d: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 111140: a1 30 26 13 00 mov 0x132630,%eax <== NOT EXECUTED 111145: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 111148: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11114b: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 11114e: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 111151: 89 08 mov %ecx,(%eax) <== NOT EXECUTED name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 111153: e8 94 45 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 111158: 31 c0 xor %eax,%eax <== NOT EXECUTED 11115a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11115d: eb 0c jmp 11116b <== NOT EXECUTED return RTEMS_SUCCESSFUL; 11115f: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 111164: eb 05 jmp 11116b <== NOT EXECUTED 111166: b8 08 00 00 00 mov $0x8,%eax <== NOT EXECUTED } 11116b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11116e: 5b pop %ebx <== NOT EXECUTED 11116f: 5e pop %esi <== NOT EXECUTED 111170: 5f pop %edi <== NOT EXECUTED 111171: c9 leave <== NOT EXECUTED 111172: c3 ret <== NOT EXECUTED 00111174 : */ rtems_status_code rtems_partition_delete( Objects_Id id ) { 111174: 55 push %ebp <== NOT EXECUTED 111175: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111177: 53 push %ebx <== NOT EXECUTED 111178: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED ); /** * This routine returns the block of memory which begins * at @a starting_address to @a the_heap. Any coalescing which is * possible with the freeing of this routine is performed. 11117b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 11117e: 50 push %eax <== NOT EXECUTED 11117f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111182: 68 14 26 13 00 push $0x132614 <== NOT EXECUTED 111187: e8 a0 3d 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 11118c: 89 c3 mov %eax,%ebx <== NOT EXECUTED register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 11118e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111191: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 111196: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 11119a: 75 36 jne 1111d2 <== NOT EXECUTED case OBJECTS_LOCAL: if ( the_partition->number_of_used_blocks == 0 ) { 11119c: 83 7b 20 00 cmpl $0x0,0x20(%ebx) <== NOT EXECUTED 1111a0: 75 26 jne 1111c8 <== NOT EXECUTED _Objects_Close( &_Partition_Information, &the_partition->Object ); 1111a2: 51 push %ecx <== NOT EXECUTED 1111a3: 51 push %ecx <== NOT EXECUTED 1111a4: 53 push %ebx <== NOT EXECUTED 1111a5: 68 14 26 13 00 push $0x132614 <== NOT EXECUTED 1111aa: e8 71 39 00 00 call 114b20 <_Objects_Close> <== NOT EXECUTED size_t *size ); /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. 1111af: 58 pop %eax <== NOT EXECUTED 1111b0: 5a pop %edx <== NOT EXECUTED 1111b1: 53 push %ebx <== NOT EXECUTED 1111b2: 68 14 26 13 00 push $0x132614 <== NOT EXECUTED 1111b7: e8 00 3c 00 00 call 114dbc <_Objects_Free> <== NOT EXECUTED 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 1111bc: e8 2b 45 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 1111c1: 31 c0 xor %eax,%eax <== NOT EXECUTED 1111c3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1111c6: eb 0a jmp 1111d2 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 1111c8: e8 1f 45 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 1111cd: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1111d2: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1111d5: c9 leave <== NOT EXECUTED 1111d6: c3 ret <== NOT EXECUTED 001111d8 : rtems_status_code rtems_partition_get_buffer( Objects_Id id, void **buffer ) { 1111d8: 55 push %ebp <== NOT EXECUTED 1111d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1111db: 57 push %edi <== NOT EXECUTED 1111dc: 56 push %esi <== NOT EXECUTED 1111dd: 53 push %ebx <== NOT EXECUTED 1111de: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1111e1: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 1111e4: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 1111e9: 85 ff test %edi,%edi <== NOT EXECUTED 1111eb: 74 4f je 11123c <== NOT EXECUTED ); /** * This routine returns the block of memory which begins * at @a starting_address to @a the_heap. Any coalescing which is * possible with the freeing of this routine is performed. 1111ed: 50 push %eax <== NOT EXECUTED 1111ee: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 1111f1: 50 push %eax <== NOT EXECUTED 1111f2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1111f5: 68 14 26 13 00 push $0x132614 <== NOT EXECUTED 1111fa: e8 2d 3d 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 1111ff: 89 c3 mov %eax,%ebx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 111201: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111204: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 111209: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 11120d: 75 2d jne 11123c <== NOT EXECUTED #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of 11120f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111212: 8d 43 24 lea 0x24(%ebx),%eax <== NOT EXECUTED 111215: 50 push %eax <== NOT EXECUTED 111216: e8 c1 27 00 00 call 1139dc <_Chain_Get> <== NOT EXECUTED 11121b: 89 c6 mov %eax,%esi <== NOT EXECUTED case OBJECTS_LOCAL: the_buffer = _Partition_Allocate_buffer( the_partition ); if ( the_buffer ) { 11121d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111220: 85 c0 test %eax,%eax <== NOT EXECUTED 111222: 74 0e je 111232 <== NOT EXECUTED the_partition->number_of_used_blocks += 1; 111224: ff 43 20 incl 0x20(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 111227: e8 c0 44 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED *buffer = the_buffer; 11122c: 89 37 mov %esi,(%edi) <== NOT EXECUTED 11122e: 31 c0 xor %eax,%eax <== NOT EXECUTED 111230: eb 0a jmp 11123c <== NOT EXECUTED return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 111232: e8 b5 44 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 111237: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11123c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11123f: 5b pop %ebx <== NOT EXECUTED 111240: 5e pop %esi <== NOT EXECUTED 111241: 5f pop %edi <== NOT EXECUTED 111242: c9 leave <== NOT EXECUTED 111243: c3 ret <== NOT EXECUTED 00111244 : rtems_status_code rtems_partition_ident( rtems_name name, uint32_t node, Objects_Id *id ) { 111244: 55 push %ebp <== NOT EXECUTED 111245: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111247: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( &_Partition_Information, name, node, id ); 11124a: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 11124d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111250: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111253: 68 14 26 13 00 push $0x132614 <== NOT EXECUTED 111258: e8 17 3e 00 00 call 115074 <_Objects_Name_to_id_u32> <== NOT EXECUTED 11125d: 8b 04 85 58 7f 12 00 mov 0x127f58(,%eax,4),%eax <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; } 111264: c9 leave <== NOT EXECUTED 111265: c3 ret <== NOT EXECUTED 00111268 : rtems_status_code rtems_partition_return_buffer( Objects_Id id, void *buffer ) { 111268: 55 push %ebp <== NOT EXECUTED 111269: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11126b: 56 push %esi <== NOT EXECUTED 11126c: 53 push %ebx <== NOT EXECUTED 11126d: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 111270: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED ); /** * This routine returns the block of memory which begins * at @a starting_address to @a the_heap. Any coalescing which is * possible with the freeing of this routine is performed. 111273: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 111276: 50 push %eax <== NOT EXECUTED 111277: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11127a: 68 14 26 13 00 push $0x132614 <== NOT EXECUTED 11127f: e8 a8 3c 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 111284: 89 c3 mov %eax,%ebx <== NOT EXECUTED register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 111286: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111289: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 11128e: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 111292: 75 3c jne 1112d0 <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); 111294: 8b 4b 10 mov 0x10(%ebx),%ecx <== NOT EXECUTED /** * This function attempts to allocate a memory block of @a size bytes from 111297: 39 ce cmp %ecx,%esi <== NOT EXECUTED 111299: 0f 93 c0 setae %al <== NOT EXECUTED 11129c: 89 ca mov %ecx,%edx <== NOT EXECUTED 11129e: 03 53 14 add 0x14(%ebx),%edx <== NOT EXECUTED 1112a1: 39 d6 cmp %edx,%esi <== NOT EXECUTED 1112a3: 0f 96 c2 setbe %dl <== NOT EXECUTED 1112a6: 84 c2 test %al,%dl <== NOT EXECUTED 1112a8: 74 2d je 1112d7 <== NOT EXECUTED 1112aa: 89 f0 mov %esi,%eax <== NOT EXECUTED 1112ac: 29 c8 sub %ecx,%eax <== NOT EXECUTED 1112ae: 31 d2 xor %edx,%edx <== NOT EXECUTED 1112b0: f7 73 18 divl 0x18(%ebx) <== NOT EXECUTED 1112b3: 85 d2 test %edx,%edx <== NOT EXECUTED 1112b5: 75 20 jne 1112d7 <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 1112b7: 50 push %eax <== NOT EXECUTED 1112b8: 50 push %eax <== NOT EXECUTED 1112b9: 56 push %esi <== NOT EXECUTED 1112ba: 8d 43 24 lea 0x24(%ebx),%eax <== NOT EXECUTED 1112bd: 50 push %eax <== NOT EXECUTED 1112be: e8 f5 26 00 00 call 1139b8 <_Chain_Append> <== NOT EXECUTED case OBJECTS_LOCAL: if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) { _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; 1112c3: ff 4b 20 decl 0x20(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 1112c6: e8 21 44 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 1112cb: 31 c0 xor %eax,%eax <== NOT EXECUTED 1112cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1112d0: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1112d3: 5b pop %ebx <== NOT EXECUTED 1112d4: 5e pop %esi <== NOT EXECUTED 1112d5: c9 leave <== NOT EXECUTED 1112d6: c3 ret <== NOT EXECUTED _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 1112d7: e8 10 44 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 1112dc: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 1112e1: eb ed jmp 1112d0 <== NOT EXECUTED 001107b8 : void *internal_start, void *external_start, uint32_t length, Objects_Id *id ) { 1107b8: 55 push %ebp <== NOT EXECUTED 1107b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1107bb: 57 push %edi <== NOT EXECUTED 1107bc: 56 push %esi <== NOT EXECUTED 1107bd: 53 push %ebx <== NOT EXECUTED 1107be: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1107c1: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1107c4: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name) ) 1107c7: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 1107cc: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 1107d0: 74 6f je 110841 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 1107d2: 83 7d 18 00 cmpl $0x0,0x18(%ebp) <== NOT EXECUTED 1107d6: 74 64 je 11083c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( internal_start ) || 1107d8: 89 f8 mov %edi,%eax <== NOT EXECUTED 1107da: 09 f0 or %esi,%eax <== NOT EXECUTED 1107dc: a8 03 test $0x3,%al <== NOT EXECUTED 1107de: 75 5c jne 11083c <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1107e0: a1 e0 27 13 00 mov 0x1327e0,%eax <== NOT EXECUTED 1107e5: 40 inc %eax <== NOT EXECUTED 1107e6: a3 e0 27 13 00 mov %eax,0x1327e0 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** * This routine initializes @a the_heap record to manage the 1107eb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1107ee: 68 d4 25 13 00 push $0x1325d4 <== NOT EXECUTED 1107f3: e8 b4 42 00 00 call 114aac <_Objects_Allocate> <== NOT EXECUTED 1107f8: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { 1107fa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1107fd: 85 c0 test %eax,%eax <== NOT EXECUTED 1107ff: 75 0c jne 11080d <== NOT EXECUTED _Thread_Enable_dispatch(); 110801: e8 e6 4e 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 110806: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 11080b: eb 34 jmp 110841 <== NOT EXECUTED return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; 11080d: 89 70 10 mov %esi,0x10(%eax) <== NOT EXECUTED the_port->external_base = external_start; 110810: 89 78 14 mov %edi,0x14(%eax) <== NOT EXECUTED the_port->length = length - 1; 110813: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 110816: 48 dec %eax <== NOT EXECUTED 110817: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED 11081a: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 11081d: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 110820: a1 f0 25 13 00 mov 0x1325f0,%eax <== NOT EXECUTED 110825: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 110828: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11082b: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED &_Dual_ported_memory_Information, &the_port->Object, (Objects_Name) name ); *id = the_port->Object.id; 11082e: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 110831: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 110833: e8 b4 4e 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 110838: 31 c0 xor %eax,%eax <== NOT EXECUTED 11083a: eb 05 jmp 110841 <== NOT EXECUTED return RTEMS_SUCCESSFUL; 11083c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED } 110841: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 110844: 5b pop %ebx <== NOT EXECUTED 110845: 5e pop %esi <== NOT EXECUTED 110846: 5f pop %edi <== NOT EXECUTED 110847: c9 leave <== NOT EXECUTED 110848: c3 ret <== NOT EXECUTED 0011084c : */ rtems_status_code rtems_port_delete( Objects_Id id ) { 11084c: 55 push %ebp <== NOT EXECUTED 11084d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11084f: 53 push %ebx <== NOT EXECUTED 110850: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add 110853: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 110856: 50 push %eax <== NOT EXECUTED 110857: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11085a: 68 d4 25 13 00 push $0x1325d4 <== NOT EXECUTED 11085f: e8 c8 46 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 110864: 89 c3 mov %eax,%ebx <== NOT EXECUTED register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 110866: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110869: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 11086e: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 110872: 75 24 jne 110898 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Dual_ported_memory_Information, &the_port->Object ); 110874: 51 push %ecx <== NOT EXECUTED 110875: 51 push %ecx <== NOT EXECUTED 110876: 53 push %ebx <== NOT EXECUTED 110877: 68 d4 25 13 00 push $0x1325d4 <== NOT EXECUTED 11087c: e8 9f 42 00 00 call 114b20 <_Objects_Close> <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ 110881: 58 pop %eax <== NOT EXECUTED 110882: 5a pop %edx <== NOT EXECUTED 110883: 53 push %ebx <== NOT EXECUTED 110884: 68 d4 25 13 00 push $0x1325d4 <== NOT EXECUTED 110889: e8 2e 45 00 00 call 114dbc <_Objects_Free> <== NOT EXECUTED _Dual_ported_memory_Free( the_port ); _Thread_Enable_dispatch(); 11088e: e8 59 4e 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 110893: 31 c0 xor %eax,%eax <== NOT EXECUTED 110895: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110898: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11089b: c9 leave <== NOT EXECUTED 11089c: c3 ret <== NOT EXECUTED 001108a0 : rtems_status_code rtems_port_external_to_internal( Objects_Id id, void *external, void **internal ) { 1108a0: 55 push %ebp <== NOT EXECUTED 1108a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1108a3: 56 push %esi <== NOT EXECUTED 1108a4: 53 push %ebx <== NOT EXECUTED 1108a5: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 1108a8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1108ab: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !internal ) 1108ae: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 1108b3: 85 db test %ebx,%ebx <== NOT EXECUTED 1108b5: 74 3c je 1108f3 <== NOT EXECUTED * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add 1108b7: 50 push %eax <== NOT EXECUTED 1108b8: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1108bb: 50 push %eax <== NOT EXECUTED 1108bc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1108bf: 68 d4 25 13 00 push $0x1325d4 <== NOT EXECUTED 1108c4: e8 63 46 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 1108c9: 89 c1 mov %eax,%ecx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 1108cb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1108ce: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1108d3: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 1108d7: 75 1a jne 1108f3 <== NOT EXECUTED * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 1108d9: 89 f2 mov %esi,%edx <== NOT EXECUTED 1108db: 2b 51 14 sub 0x14(%ecx),%edx <== NOT EXECUTED case OBJECTS_LOCAL: ending = _Addresses_Subtract( external, the_port->external_base ); if ( ending > the_port->length ) 1108de: 3b 51 18 cmp 0x18(%ecx),%edx <== NOT EXECUTED 1108e1: 76 04 jbe 1108e7 <== NOT EXECUTED *internal = external; 1108e3: 89 33 mov %esi,(%ebx) <== NOT EXECUTED 1108e5: eb 05 jmp 1108ec <== NOT EXECUTED else *internal = _Addresses_Add_offset( the_port->internal_base, 1108e7: 03 51 10 add 0x10(%ecx),%edx <== NOT EXECUTED 1108ea: 89 13 mov %edx,(%ebx) <== NOT EXECUTED ending ); _Thread_Enable_dispatch(); 1108ec: e8 fb 4d 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 1108f1: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1108f3: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1108f6: 5b pop %ebx <== NOT EXECUTED 1108f7: 5e pop %esi <== NOT EXECUTED 1108f8: c9 leave <== NOT EXECUTED 1108f9: c3 ret <== NOT EXECUTED 001108fc : rtems_status_code rtems_port_ident( rtems_name name, Objects_Id *id ) { 1108fc: 55 push %ebp <== NOT EXECUTED 1108fd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1108ff: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 110902: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 110905: 6a 00 push $0x0 <== NOT EXECUTED 110907: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11090a: 68 d4 25 13 00 push $0x1325d4 <== NOT EXECUTED 11090f: e8 60 47 00 00 call 115074 <_Objects_Name_to_id_u32> <== NOT EXECUTED 110914: 8b 04 85 58 7f 12 00 mov 0x127f58(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_ALL_NODES, id ); return _Status_Object_name_errors_to_status[ status ]; } 11091b: c9 leave <== NOT EXECUTED 11091c: c3 ret <== NOT EXECUTED 00110920 : rtems_status_code rtems_port_internal_to_external( Objects_Id id, void *internal, void **external ) { 110920: 55 push %ebp <== NOT EXECUTED 110921: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110923: 56 push %esi <== NOT EXECUTED 110924: 53 push %ebx <== NOT EXECUTED 110925: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 110928: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 11092b: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !external ) 11092e: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 110933: 85 db test %ebx,%ebx <== NOT EXECUTED 110935: 74 3c je 110973 <== NOT EXECUTED * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add 110937: 50 push %eax <== NOT EXECUTED 110938: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 11093b: 50 push %eax <== NOT EXECUTED 11093c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11093f: 68 d4 25 13 00 push $0x1325d4 <== NOT EXECUTED 110944: e8 e3 45 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 110949: 89 c1 mov %eax,%ecx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 11094b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11094e: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 110953: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 110957: 75 1a jne 110973 <== NOT EXECUTED * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 110959: 89 f2 mov %esi,%edx <== NOT EXECUTED 11095b: 2b 51 10 sub 0x10(%ecx),%edx <== NOT EXECUTED case OBJECTS_LOCAL: ending = _Addresses_Subtract( internal, the_port->internal_base ); if ( ending > the_port->length ) 11095e: 3b 51 18 cmp 0x18(%ecx),%edx <== NOT EXECUTED 110961: 76 04 jbe 110967 <== NOT EXECUTED *external = internal; 110963: 89 33 mov %esi,(%ebx) <== NOT EXECUTED 110965: eb 05 jmp 11096c <== NOT EXECUTED else *external = _Addresses_Add_offset( the_port->external_base, 110967: 03 51 14 add 0x14(%ecx),%edx <== NOT EXECUTED 11096a: 89 13 mov %edx,(%ebx) <== NOT EXECUTED ending ); _Thread_Enable_dispatch(); 11096c: e8 7b 4d 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 110971: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110973: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 110976: 5b pop %ebx <== NOT EXECUTED 110977: 5e pop %esi <== NOT EXECUTED 110978: c9 leave <== NOT EXECUTED 110979: c3 ret <== NOT EXECUTED 001112e4 : */ rtems_status_code rtems_rate_monotonic_cancel( Objects_Id id ) { 1112e4: 55 push %ebp <== NOT EXECUTED 1112e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1112e7: 53 push %ebx <== NOT EXECUTED 1112e8: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 1112eb: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1112ee: 50 push %eax <== NOT EXECUTED 1112ef: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1112f2: 68 54 26 13 00 push $0x132654 <== NOT EXECUTED 1112f7: e8 30 3c 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 1112fc: 89 c3 mov %eax,%ebx <== NOT EXECUTED Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 1112fe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111301: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 111306: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 11130a: 75 34 jne 111340 <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 11130c: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 11130f: 3b 05 a0 28 13 00 cmp 0x1328a0,%eax <== NOT EXECUTED 111315: 74 0c je 111323 <== NOT EXECUTED _Thread_Enable_dispatch(); 111317: e8 d0 43 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 11131c: b8 17 00 00 00 mov $0x17,%eax <== NOT EXECUTED 111321: eb 1d jmp 111340 <== NOT EXECUTED return RTEMS_NOT_OWNER_OF_RESOURCE; } (void) _Watchdog_Remove( &the_period->Timer ); 111323: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111326: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 111329: 50 push %eax <== NOT EXECUTED 11132a: e8 f1 55 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED the_period->state = RATE_MONOTONIC_INACTIVE; 11132f: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 111336: e8 b1 43 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 11133b: 31 c0 xor %eax,%eax <== NOT EXECUTED 11133d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111340: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111343: c9 leave <== NOT EXECUTED 111344: c3 ret <== NOT EXECUTED 00109cb8 : rtems_status_code rtems_rate_monotonic_create( rtems_name name, Objects_Id *id ) { 109cb8: 55 push %ebp <== NOT EXECUTED 109cb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109cbb: 57 push %edi <== NOT EXECUTED 109cbc: 56 push %esi <== NOT EXECUTED 109cbd: 53 push %ebx <== NOT EXECUTED 109cbe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109cc1: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 109cc4: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 109cc9: 85 f6 test %esi,%esi <== NOT EXECUTED 109ccb: 0f 84 ac 00 00 00 je 109d7d <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 109cd1: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 109cd6: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 109cda: 0f 84 9d 00 00 00 je 109d7d <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109ce0: a1 c4 0a 12 00 mov 0x120ac4,%eax <== NOT EXECUTED 109ce5: 40 inc %eax <== NOT EXECUTED 109ce6: a3 c4 0a 12 00 mov %eax,0x120ac4 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 109ceb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109cee: 68 cc 09 12 00 push $0x1209cc <== NOT EXECUTED 109cf3: e8 e4 1a 00 00 call 10b7dc <_Objects_Allocate> <== NOT EXECUTED 109cf8: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { 109cfa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109cfd: 85 c0 test %eax,%eax <== NOT EXECUTED 109cff: 75 0c jne 109d0d <== NOT EXECUTED _Thread_Enable_dispatch(); 109d01: e8 b2 27 00 00 call 10c4b8 <_Thread_Enable_dispatch> <== NOT EXECUTED 109d06: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 109d0b: eb 70 jmp 109d7d <== NOT EXECUTED return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 109d0d: a1 84 0b 12 00 mov 0x120b84,%eax <== NOT EXECUTED 109d12: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED the_period->state = RATE_MONOTONIC_INACTIVE; 109d15: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 109d1c: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 109d23: c7 43 2c 00 00 00 00 movl $0x0,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 109d2a: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx) <== NOT EXECUTED * the heap 109d31: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL ); _Rate_monotonic_Reset_statistics( the_period ); 109d38: 8d 7b 54 lea 0x54(%ebx),%edi <== NOT EXECUTED 109d3b: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 109d40: 31 c0 xor %eax,%eax <== NOT EXECUTED 109d42: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED 109d44: c7 43 5c ff ff ff 7f movl $0x7fffffff,0x5c(%ebx) <== NOT EXECUTED 109d4b: c7 43 60 ff ff ff 7f movl $0x7fffffff,0x60(%ebx) <== NOT EXECUTED 109d52: c7 43 74 ff ff ff 7f movl $0x7fffffff,0x74(%ebx) <== NOT EXECUTED 109d59: c7 43 78 ff ff ff 7f movl $0x7fffffff,0x78(%ebx) <== NOT EXECUTED 109d60: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 109d63: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 109d66: a1 e8 09 12 00 mov 0x1209e8,%eax <== NOT EXECUTED 109d6b: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 109d6e: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Rate_monotonic_Information, &the_period->Object, (Objects_Name) name ); *id = the_period->Object.id; 109d71: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 109d74: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 109d76: e8 3d 27 00 00 call 10c4b8 <_Thread_Enable_dispatch> <== NOT EXECUTED 109d7b: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 109d7d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109d80: 5b pop %ebx <== NOT EXECUTED 109d81: 5e pop %esi <== NOT EXECUTED 109d82: 5f pop %edi <== NOT EXECUTED 109d83: c9 leave <== NOT EXECUTED 109d84: c3 ret <== NOT EXECUTED 00111418 : */ rtems_status_code rtems_rate_monotonic_delete( Objects_Id id ) { 111418: 55 push %ebp <== NOT EXECUTED 111419: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11141b: 53 push %ebx <== NOT EXECUTED 11141c: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 11141f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 111422: 50 push %eax <== NOT EXECUTED 111423: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111426: 68 54 26 13 00 push $0x132654 <== NOT EXECUTED 11142b: e8 fc 3a 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 111430: 89 c3 mov %eax,%ebx <== NOT EXECUTED Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 111432: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111435: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 11143a: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 11143e: 75 36 jne 111476 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Rate_monotonic_Information, &the_period->Object ); 111440: 51 push %ecx <== NOT EXECUTED 111441: 51 push %ecx <== NOT EXECUTED 111442: 53 push %ebx <== NOT EXECUTED 111443: 68 54 26 13 00 push $0x132654 <== NOT EXECUTED 111448: e8 d3 36 00 00 call 114b20 <_Objects_Close> <== NOT EXECUTED (void) _Watchdog_Remove( &the_period->Timer ); 11144d: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 111450: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 111453: e8 c8 54 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED the_period->state = RATE_MONOTONIC_INACTIVE; 111458: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) <== NOT EXECUTED * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. 11145f: 58 pop %eax <== NOT EXECUTED 111460: 5a pop %edx <== NOT EXECUTED 111461: 53 push %ebx <== NOT EXECUTED 111462: 68 54 26 13 00 push $0x132654 <== NOT EXECUTED 111467: e8 50 39 00 00 call 114dbc <_Objects_Free> <== NOT EXECUTED _Rate_monotonic_Free( the_period ); _Thread_Enable_dispatch(); 11146c: e8 7b 42 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 111471: 31 c0 xor %eax,%eax <== NOT EXECUTED 111473: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111476: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111479: c9 leave <== NOT EXECUTED 11147a: c3 ret <== NOT EXECUTED 001294a4 : rtems_status_code rtems_rate_monotonic_get_statistics( Objects_Id id, rtems_rate_monotonic_period_statistics *statistics ) { 1294a4: 55 push %ebp <== NOT EXECUTED 1294a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1294a7: 57 push %edi <== NOT EXECUTED 1294a8: 56 push %esi <== NOT EXECUTED 1294a9: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 1294ac: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 1294af: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 1294b4: 85 ff test %edi,%edi <== NOT EXECUTED 1294b6: 74 33 je 1294eb <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 1294b8: 50 push %eax <== NOT EXECUTED 1294b9: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1294bc: 50 push %eax <== NOT EXECUTED 1294bd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1294c0: 68 54 a1 15 00 push $0x15a154 <== NOT EXECUTED 1294c5: e8 06 5c fe ff call 10f0d0 <_Objects_Get> <== NOT EXECUTED 1294ca: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 1294cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1294cf: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1294d4: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 1294d8: 75 11 jne 1294eb <== NOT EXECUTED case OBJECTS_LOCAL: *statistics = the_period->Statistics; 1294da: 8d 72 54 lea 0x54(%edx),%esi <== NOT EXECUTED 1294dd: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 1294e2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 1294e4: e8 57 64 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 1294e9: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1294eb: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1294ee: 5e pop %esi <== NOT EXECUTED 1294ef: 5f pop %edi <== NOT EXECUTED 1294f0: c9 leave <== NOT EXECUTED 1294f1: c3 ret <== NOT EXECUTED 001294f4 : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 1294f4: 55 push %ebp <== NOT EXECUTED 1294f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1294f7: 57 push %edi <== NOT EXECUTED 1294f8: 56 push %esi <== NOT EXECUTED 1294f9: 53 push %ebx <== NOT EXECUTED 1294fa: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1294fd: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 129500: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 129505: 85 f6 test %esi,%esi <== NOT EXECUTED 129507: 0f 84 91 00 00 00 je 12959e <== NOT EXECUTED 12950d: 50 push %eax <== NOT EXECUTED 12950e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 129511: 50 push %eax <== NOT EXECUTED 129512: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 129515: 68 54 a1 15 00 push $0x15a154 <== NOT EXECUTED 12951a: e8 b1 5b fe ff call 10f0d0 <_Objects_Get> <== NOT EXECUTED 12951f: 89 c7 mov %eax,%edi <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 129521: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129524: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 129529: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 12952d: 75 6f jne 12959e <== NOT EXECUTED case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 12952f: 8b 47 50 mov 0x50(%edi),%eax <== NOT EXECUTED 129532: 31 d2 xor %edx,%edx <== NOT EXECUTED 129534: 85 c0 test %eax,%eax <== NOT EXECUTED 129536: 74 03 je 12953b <== NOT EXECUTED 129538: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 12953b: 89 16 mov %edx,(%esi) <== NOT EXECUTED status->state = the_period->state; 12953d: 8b 47 38 mov 0x38(%edi),%eax <== NOT EXECUTED 129540: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED if ( status->state == RATE_MONOTONIC_INACTIVE ) { 129543: 85 c0 test %eax,%eax <== NOT EXECUTED 129545: 75 1e jne 129565 <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS status->since_last_period.tv_sec = 0; 129547: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) <== NOT EXECUTED status->since_last_period.tv_nsec = 0; 12954e: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) <== NOT EXECUTED #else status->since_last_period = 0; #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS status->executed_since_last_period.tv_sec = 0; 129555: c7 46 10 00 00 00 00 movl $0x0,0x10(%esi) <== NOT EXECUTED status->executed_since_last_period.tv_nsec = 0; 12955c: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED 129563: eb 32 jmp 129597 <== NOT EXECUTED * This lets them share one single invocation of _TOD_Get_uptime(). */ #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) struct timespec uptime; _TOD_Get_uptime( &uptime ); 129565: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129568: 8d 5d e8 lea -0x18(%ebp),%ebx <== NOT EXECUTED 12956b: 53 push %ebx <== NOT EXECUTED 12956c: e8 6f 83 ff ff call 1218e0 <_TOD_Get_uptime> <== NOT EXECUTED #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 129571: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 129574: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED 129577: 50 push %eax <== NOT EXECUTED 129578: 53 push %ebx <== NOT EXECUTED 129579: 8d 47 44 lea 0x44(%edi),%eax <== NOT EXECUTED 12957c: 50 push %eax <== NOT EXECUTED 12957d: e8 16 6f fe ff call 110498 <_Timespec_Subtract> <== NOT EXECUTED status->since_last_period = _Watchdog_Ticks_since_boot - the_period->time_at_period; #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _Timespec_Subtract( 129582: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 129585: 8d 46 10 lea 0x10(%esi),%eax <== NOT EXECUTED 129588: 50 push %eax <== NOT EXECUTED 129589: 53 push %ebx <== NOT EXECUTED 12958a: 68 bc 9c 15 00 push $0x159cbc <== NOT EXECUTED 12958f: e8 04 6f fe ff call 110498 <_Timespec_Subtract> <== NOT EXECUTED 129594: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_period->owner->cpu_time_used - the_period->owner_executed_at_period; #endif } _Thread_Enable_dispatch(); 129597: e8 a4 63 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 12959c: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12959e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1295a1: 5b pop %ebx <== NOT EXECUTED 1295a2: 5e pop %esi <== NOT EXECUTED 1295a3: 5f pop %edi <== NOT EXECUTED 1295a4: c9 leave <== NOT EXECUTED 1295a5: c3 ret <== NOT EXECUTED 00109d88 : rtems_status_code rtems_rate_monotonic_ident( rtems_name name, Objects_Id *id ) { 109d88: 55 push %ebp <== NOT EXECUTED 109d89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109d8b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 109d8e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109d91: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 109d96: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109d99: 68 cc 09 12 00 push $0x1209cc <== NOT EXECUTED 109d9e: e8 9d 20 00 00 call 10be40 <_Objects_Name_to_id_u32> <== NOT EXECUTED 109da3: 8b 04 85 fc 9c 11 00 mov 0x119cfc(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 109daa: c9 leave <== NOT EXECUTED 109dab: c3 ret <== NOT EXECUTED 00109f52 : rtems_status_code rtems_rate_monotonic_period( Objects_Id id, rtems_interval length ) { 109f52: 55 push %ebp <== NOT EXECUTED 109f53: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109f55: 57 push %edi <== NOT EXECUTED 109f56: 56 push %esi <== NOT EXECUTED 109f57: 53 push %ebx <== NOT EXECUTED 109f58: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 109f5b: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 109f5e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 109f61: 50 push %eax <== NOT EXECUTED 109f62: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109f65: 68 cc 09 12 00 push $0x1209cc <== NOT EXECUTED 109f6a: e8 89 1d 00 00 call 10bcf8 <_Objects_Get> <== NOT EXECUTED 109f6f: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 109f71: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109f74: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 109f78: 0f 85 44 01 00 00 jne 10a0c2 <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 109f7e: 8b 40 50 mov 0x50(%eax),%eax <== NOT EXECUTED 109f81: 3b 05 84 0b 12 00 cmp 0x120b84,%eax <== NOT EXECUTED 109f87: 74 0f je 109f98 <== NOT EXECUTED _Thread_Enable_dispatch(); 109f89: e8 2a 25 00 00 call 10c4b8 <_Thread_Enable_dispatch> <== NOT EXECUTED 109f8e: bb 17 00 00 00 mov $0x17,%ebx <== NOT EXECUTED 109f93: e9 2f 01 00 00 jmp 10a0c7 <== NOT EXECUTED return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 109f98: 85 ff test %edi,%edi <== NOT EXECUTED 109f9a: 75 21 jne 109fbd <== NOT EXECUTED switch ( the_period->state ) { 109f9c: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 109f9f: bb 0b 00 00 00 mov $0xb,%ebx <== NOT EXECUTED 109fa4: 85 c0 test %eax,%eax <== NOT EXECUTED 109fa6: 74 0b je 109fb3 <== NOT EXECUTED 109fa8: 83 e8 03 sub $0x3,%eax <== NOT EXECUTED 109fab: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109fae: 19 db sbb %ebx,%ebx <== NOT EXECUTED 109fb0: 83 e3 06 and $0x6,%ebx <== NOT EXECUTED case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 109fb3: e8 00 25 00 00 call 10c4b8 <_Thread_Enable_dispatch> <== NOT EXECUTED 109fb8: e9 0a 01 00 00 jmp 10a0c7 <== NOT EXECUTED return( return_value ); } _ISR_Disable( level ); 109fbd: 9c pushf <== NOT EXECUTED 109fbe: fa cli <== NOT EXECUTED 109fbf: 5e pop %esi <== NOT EXECUTED switch ( the_period->state ) { 109fc0: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 109fc3: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109fc6: 74 60 je 10a028 <== NOT EXECUTED 109fc8: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 109fcb: 0f 84 ba 00 00 00 je 10a08b <== NOT EXECUTED 109fd1: 85 c0 test %eax,%eax <== NOT EXECUTED 109fd3: 0f 85 e9 00 00 00 jne 10a0c2 <== NOT EXECUTED case RATE_MONOTONIC_INACTIVE: { _ISR_Enable( level ); 109fd9: 56 push %esi <== NOT EXECUTED 109fda: 9d popf <== NOT EXECUTED /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 109fdb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109fde: 53 push %ebx <== NOT EXECUTED 109fdf: e8 c8 fd ff ff call 109dac <_Rate_monotonic_Initiate_statistics> <== NOT EXECUTED the_period->state = RATE_MONOTONIC_ACTIVE; 109fe4: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 109feb: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 109ff2: c7 43 2c e8 a2 10 00 movl $0x10a2e8,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 109ff9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109ffc: 89 43 30 mov %eax,0x30(%ebx) <== NOT EXECUTED * the heap 109fff: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 10a006: 89 7b 4c mov %edi,0x4c(%ebx) <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10a009: 89 7b 1c mov %edi,0x1c(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10a00c: 58 pop %eax <== NOT EXECUTED 10a00d: 5a pop %edx <== NOT EXECUTED 10a00e: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10a011: 50 push %eax <== NOT EXECUTED 10a012: 68 a4 0b 12 00 push $0x120ba4 <== NOT EXECUTED 10a017: e8 f8 33 00 00 call 10d414 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 10a01c: e8 97 24 00 00 call 10c4b8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a021: 31 db xor %ebx,%ebx <== NOT EXECUTED 10a023: e9 95 00 00 00 jmp 10a0bd <== NOT EXECUTED case RATE_MONOTONIC_ACTIVE: /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 10a028: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a02b: 53 push %ebx <== NOT EXECUTED 10a02c: e8 e3 fd ff ff call 109e14 <_Rate_monotonic_Update_statistics> <== NOT EXECUTED /* * 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; 10a031: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) <== NOT EXECUTED the_period->next_length = length; 10a038: 89 7b 4c mov %edi,0x4c(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10a03b: 56 push %esi <== NOT EXECUTED 10a03c: 9d popf <== NOT EXECUTED _Thread_Executing->Wait.id = the_period->Object.id; 10a03d: 8b 15 84 0b 12 00 mov 0x120b84,%edx <== NOT EXECUTED 10a043: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10a046: 89 42 20 mov %eax,0x20(%edx) <== NOT EXECUTED _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10a049: 5e pop %esi <== NOT EXECUTED 10a04a: 5f pop %edi <== NOT EXECUTED 10a04b: 68 00 40 00 00 push $0x4000 <== NOT EXECUTED 10a050: 52 push %edx <== NOT EXECUTED 10a051: e8 7e 2c 00 00 call 10ccd4 <_Thread_Set_state> <== NOT EXECUTED /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 10a056: 9c pushf <== NOT EXECUTED 10a057: fa cli <== NOT EXECUTED 10a058: 58 pop %eax <== NOT EXECUTED local_state = the_period->state; 10a059: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED the_period->state = RATE_MONOTONIC_ACTIVE; 10a05c: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10a063: 50 push %eax <== NOT EXECUTED 10a064: 9d popf <== NOT EXECUTED /* * 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 ) 10a065: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a068: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 10a06b: 75 15 jne 10a082 <== NOT EXECUTED _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10a06d: 51 push %ecx <== NOT EXECUTED 10a06e: 51 push %ecx <== NOT EXECUTED 10a06f: 68 00 40 00 00 push $0x4000 <== NOT EXECUTED 10a074: ff 35 84 0b 12 00 pushl 0x120b84 <== NOT EXECUTED 10a07a: e8 b9 20 00 00 call 10c138 <_Thread_Clear_state> <== NOT EXECUTED 10a07f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Enable_dispatch(); 10a082: e8 31 24 00 00 call 10c4b8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a087: 31 db xor %ebx,%ebx <== NOT EXECUTED 10a089: eb 3c jmp 10a0c7 <== NOT EXECUTED case RATE_MONOTONIC_EXPIRED: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 10a08b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a08e: 53 push %ebx <== NOT EXECUTED 10a08f: e8 80 fd ff ff call 109e14 <_Rate_monotonic_Update_statistics> <== NOT EXECUTED _ISR_Enable( level ); 10a094: 56 push %esi <== NOT EXECUTED 10a095: 9d popf <== NOT EXECUTED the_period->state = RATE_MONOTONIC_ACTIVE; 10a096: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx) <== NOT EXECUTED the_period->next_length = length; 10a09d: 89 7b 4c mov %edi,0x4c(%ebx) <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10a0a0: 89 7b 1c mov %edi,0x1c(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10a0a3: 58 pop %eax <== NOT EXECUTED 10a0a4: 5a pop %edx <== NOT EXECUTED 10a0a5: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10a0a8: 50 push %eax <== NOT EXECUTED 10a0a9: 68 a4 0b 12 00 push $0x120ba4 <== NOT EXECUTED 10a0ae: e8 61 33 00 00 call 10d414 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 10a0b3: e8 00 24 00 00 call 10c4b8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a0b8: bb 06 00 00 00 mov $0x6,%ebx <== NOT EXECUTED 10a0bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a0c0: eb 05 jmp 10a0c7 <== NOT EXECUTED return RTEMS_TIMEOUT; 10a0c2: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a0c7: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a0c9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a0cc: 5b pop %ebx <== NOT EXECUTED 10a0cd: 5e pop %esi <== NOT EXECUTED 10a0ce: 5f pop %edi <== NOT EXECUTED 10a0cf: c9 leave <== NOT EXECUTED 10a0d0: c3 ret <== NOT EXECUTED 00120f78 : void rtems_rate_monotonic_report_statistics( void ) { 120f78: 55 push %ebp <== NOT EXECUTED 120f79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120f7b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin ); 120f7e: 68 e4 b1 10 00 push $0x10b1e4 <== NOT EXECUTED 120f83: 6a 00 push $0x0 <== NOT EXECUTED 120f85: e8 8e fe ff ff call 120e18 <== NOT EXECUTED 120f8a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 120f8d: c9 leave <== NOT EXECUTED 120f8e: c3 ret <== NOT EXECUTED 00120e18 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 120e18: 55 push %ebp <== NOT EXECUTED 120e19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120e1b: 57 push %edi <== NOT EXECUTED 120e1c: 56 push %esi <== NOT EXECUTED 120e1d: 53 push %ebx <== NOT EXECUTED 120e1e: 83 ec 6c sub $0x6c,%esp <== NOT EXECUTED 120e21: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; if ( !print ) 120e24: 85 f6 test %esi,%esi <== NOT EXECUTED 120e26: 0f 84 44 01 00 00 je 120f70 <== NOT EXECUTED return; (*print)( context, "Period information by period\n" ); 120e2c: 51 push %ecx <== NOT EXECUTED 120e2d: 51 push %ecx <== NOT EXECUTED 120e2e: 68 35 d0 13 00 push $0x13d035 <== NOT EXECUTED 120e33: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120e36: ff d6 call *%esi <== NOT EXECUTED #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 120e38: 58 pop %eax <== NOT EXECUTED 120e39: 5a pop %edx <== NOT EXECUTED 120e3a: 68 53 d0 13 00 push $0x13d053 <== NOT EXECUTED 120e3f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120e42: ff d6 call *%esi <== NOT EXECUTED #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 120e44: 5f pop %edi <== NOT EXECUTED 120e45: 58 pop %eax <== NOT EXECUTED 120e46: 68 75 d0 13 00 push $0x13d075 <== NOT EXECUTED 120e4b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120e4e: ff d6 call *%esi <== NOT EXECUTED Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 120e50: 59 pop %ecx <== NOT EXECUTED 120e51: 5b pop %ebx <== NOT EXECUTED 120e52: 68 98 d0 13 00 push $0x13d098 <== NOT EXECUTED 120e57: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120e5a: ff d6 call *%esi <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 120e5c: 58 pop %eax <== NOT EXECUTED 120e5d: 5a pop %edx <== NOT EXECUTED 120e5e: 68 e3 d0 13 00 push $0x13d0e3 <== NOT EXECUTED 120e63: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120e66: ff d6 call *%esi <== NOT EXECUTED /* * 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 ; 120e68: 8b 3d 5c a1 15 00 mov 0x15a15c,%edi <== NOT EXECUTED 120e6e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120e71: e9 ee 00 00 00 jmp 120f64 <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 120e76: 50 push %eax <== NOT EXECUTED 120e77: 50 push %eax <== NOT EXECUTED 120e78: 8d 45 94 lea -0x6c(%ebp),%eax <== NOT EXECUTED 120e7b: 50 push %eax <== NOT EXECUTED 120e7c: 57 push %edi <== NOT EXECUTED 120e7d: e8 22 86 00 00 call 1294a4 <== NOT EXECUTED if ( status != RTEMS_SUCCESSFUL ) 120e82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120e85: 85 c0 test %eax,%eax <== NOT EXECUTED 120e87: 0f 85 d6 00 00 00 jne 120f63 <== NOT EXECUTED continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 120e8d: 50 push %eax <== NOT EXECUTED 120e8e: 50 push %eax <== NOT EXECUTED 120e8f: 8d 55 cc lea -0x34(%ebp),%edx <== NOT EXECUTED 120e92: 52 push %edx <== NOT EXECUTED 120e93: 57 push %edi <== NOT EXECUTED 120e94: e8 5b 86 00 00 call 1294f4 <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( status != RTEMS_SUCCESSFUL ) continue; #endif name[ 0 ] = '\0'; 120e99: c6 45 ef 00 movb $0x0,-0x11(%ebp) <== NOT EXECUTED if ( the_status.owner ) { 120e9d: 8b 55 cc mov -0x34(%ebp),%edx <== NOT EXECUTED 120ea0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120ea3: 85 d2 test %edx,%edx <== NOT EXECUTED 120ea5: 74 10 je 120eb7 <== NOT EXECUTED rtems_object_get_name( the_status.owner, sizeof(name), name ); 120ea7: 50 push %eax <== NOT EXECUTED 120ea8: 8d 45 ef lea -0x11(%ebp),%eax <== NOT EXECUTED 120eab: 50 push %eax <== NOT EXECUTED 120eac: 6a 05 push $0x5 <== NOT EXECUTED 120eae: 52 push %edx <== NOT EXECUTED 120eaf: e8 ac c7 fe ff call 10d660 <== NOT EXECUTED 120eb4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Print part of report line that is not dependent on granularity */ (*print)( context, 120eb7: 53 push %ebx <== NOT EXECUTED 120eb8: 53 push %ebx <== NOT EXECUTED 120eb9: ff 75 98 pushl -0x68(%ebp) <== NOT EXECUTED 120ebc: ff 75 94 pushl -0x6c(%ebp) <== NOT EXECUTED 120ebf: 8d 45 ef lea -0x11(%ebp),%eax <== NOT EXECUTED 120ec2: 50 push %eax <== NOT EXECUTED 120ec3: 57 push %edi <== NOT EXECUTED 120ec4: 68 2f d1 13 00 push $0x13d12f <== NOT EXECUTED 120ec9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120ecc: ff d6 call *%esi <== NOT EXECUTED /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 120ece: 8b 45 94 mov -0x6c(%ebp),%eax <== NOT EXECUTED 120ed1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 120ed4: 85 c0 test %eax,%eax <== NOT EXECUTED 120ed6: 75 11 jne 120ee9 <== NOT EXECUTED (*print)( context, "\n" ); 120ed8: 51 push %ecx <== NOT EXECUTED 120ed9: 51 push %ecx <== NOT EXECUTED 120eda: 68 65 d4 13 00 push $0x13d465 <== NOT EXECUTED 120edf: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120ee2: ff d6 call *%esi <== NOT EXECUTED 120ee4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120ee7: eb 7a jmp 120f63 <== NOT EXECUTED */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 120ee9: 52 push %edx <== NOT EXECUTED 120eea: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 120eed: 52 push %edx <== NOT EXECUTED 120eee: 50 push %eax <== NOT EXECUTED 120eef: 8d 45 ac lea -0x54(%ebp),%eax <== NOT EXECUTED 120ef2: 50 push %eax <== NOT EXECUTED 120ef3: e8 10 13 00 00 call 122208 <_Timespec_Divide_by_integer> <== NOT EXECUTED &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 120ef8: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 120efb: bb e8 03 00 00 mov $0x3e8,%ebx <== NOT EXECUTED 120f00: 99 cltd <== NOT EXECUTED 120f01: f7 fb idiv %ebx <== NOT EXECUTED 120f03: 50 push %eax <== NOT EXECUTED 120f04: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 120f07: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED 120f0a: 99 cltd <== NOT EXECUTED 120f0b: f7 fb idiv %ebx <== NOT EXECUTED 120f0d: 50 push %eax <== NOT EXECUTED 120f0e: ff 75 a4 pushl -0x5c(%ebp) <== NOT EXECUTED 120f11: 8b 45 a0 mov -0x60(%ebp),%eax <== NOT EXECUTED 120f14: 99 cltd <== NOT EXECUTED 120f15: f7 fb idiv %ebx <== NOT EXECUTED 120f17: 50 push %eax <== NOT EXECUTED 120f18: ff 75 9c pushl -0x64(%ebp) <== NOT EXECUTED 120f1b: 68 46 d1 13 00 push $0x13d146 <== NOT EXECUTED 120f20: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120f23: ff d6 call *%esi <== NOT EXECUTED * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 120f25: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED 120f28: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 120f2b: 50 push %eax <== NOT EXECUTED 120f2c: ff 75 94 pushl -0x6c(%ebp) <== NOT EXECUTED 120f2f: 8d 45 c4 lea -0x3c(%ebp),%eax <== NOT EXECUTED 120f32: 50 push %eax <== NOT EXECUTED 120f33: e8 d0 12 00 00 call 122208 <_Timespec_Divide_by_integer> <== NOT EXECUTED &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 120f38: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 120f3b: 99 cltd <== NOT EXECUTED 120f3c: f7 fb idiv %ebx <== NOT EXECUTED 120f3e: 50 push %eax <== NOT EXECUTED 120f3f: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 120f42: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 120f45: 99 cltd <== NOT EXECUTED 120f46: f7 fb idiv %ebx <== NOT EXECUTED 120f48: 50 push %eax <== NOT EXECUTED 120f49: ff 75 bc pushl -0x44(%ebp) <== NOT EXECUTED 120f4c: 8b 45 b8 mov -0x48(%ebp),%eax <== NOT EXECUTED 120f4f: 99 cltd <== NOT EXECUTED 120f50: f7 fb idiv %ebx <== NOT EXECUTED 120f52: 50 push %eax <== NOT EXECUTED 120f53: ff 75 b4 pushl -0x4c(%ebp) <== NOT EXECUTED 120f56: 68 65 d1 13 00 push $0x13d165 <== NOT EXECUTED 120f5b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120f5e: ff d6 call *%esi <== NOT EXECUTED 120f60: 83 c4 30 add $0x30,%esp <== NOT EXECUTED * 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++ ) { 120f63: 47 inc %edi <== NOT EXECUTED /* * 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 ; 120f64: 3b 3d 60 a1 15 00 cmp 0x15a160,%edi <== NOT EXECUTED 120f6a: 0f 86 06 ff ff ff jbe 120e76 <== NOT EXECUTED the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 120f70: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 120f73: 5b pop %ebx <== NOT EXECUTED 120f74: 5e pop %esi <== NOT EXECUTED 120f75: 5f pop %edi <== NOT EXECUTED 120f76: c9 leave <== NOT EXECUTED 120f77: c3 ret <== NOT EXECUTED 00120f90 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 120f90: 55 push %ebp <== NOT EXECUTED 120f91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120f93: 53 push %ebx <== NOT EXECUTED 120f94: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 120f97: a1 f4 9b 15 00 mov 0x159bf4,%eax <== NOT EXECUTED 120f9c: 40 inc %eax <== NOT EXECUTED 120f9d: a3 f4 9b 15 00 mov %eax,0x159bf4 <== NOT EXECUTED /* * 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 ; 120fa2: 8b 1d 5c a1 15 00 mov 0x15a15c,%ebx <== NOT EXECUTED 120fa8: eb 0d jmp 120fb7 <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_reset_statistics( id ); 120faa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 120fad: 53 push %ebx <== NOT EXECUTED 120fae: e8 15 00 00 00 call 120fc8 <== NOT EXECUTED * 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++ ) { 120fb3: 43 inc %ebx <== NOT EXECUTED 120fb4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * 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 ; 120fb7: 3b 1d 60 a1 15 00 cmp 0x15a160,%ebx <== NOT EXECUTED 120fbd: 76 eb jbe 120faa <== NOT EXECUTED /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); } 120fbf: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 120fc2: c9 leave <== NOT EXECUTED } /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); 120fc3: e9 78 e9 fe ff jmp 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 00120fc8 : */ rtems_status_code rtems_rate_monotonic_reset_statistics( Objects_Id id ) { 120fc8: 55 push %ebp <== NOT EXECUTED 120fc9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120fcb: 57 push %edi <== NOT EXECUTED 120fcc: 56 push %esi <== NOT EXECUTED 120fcd: 53 push %ebx <== NOT EXECUTED 120fce: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 120fd1: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 120fd4: 50 push %eax <== NOT EXECUTED 120fd5: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 120fd8: 68 54 a1 15 00 push $0x15a154 <== NOT EXECUTED 120fdd: e8 ee e0 fe ff call 10f0d0 <_Objects_Get> <== NOT EXECUTED 120fe2: 89 c6 mov %eax,%esi <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 120fe4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 120fe7: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 120fea: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED 120fef: 85 db test %ebx,%ebx <== NOT EXECUTED 120ff1: 75 2f jne 121022 <== NOT EXECUTED case OBJECTS_LOCAL: _Rate_monotonic_Reset_statistics( the_period ); 120ff3: 8d 78 54 lea 0x54(%eax),%edi <== NOT EXECUTED 120ff6: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 120ffb: 89 d8 mov %ebx,%eax <== NOT EXECUTED 120ffd: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED 120fff: c7 46 5c ff ff ff 7f movl $0x7fffffff,0x5c(%esi) <== NOT EXECUTED 121006: c7 46 60 ff ff ff 7f movl $0x7fffffff,0x60(%esi) <== NOT EXECUTED 12100d: c7 46 74 ff ff ff 7f movl $0x7fffffff,0x74(%esi) <== NOT EXECUTED 121014: c7 46 78 ff ff ff 7f movl $0x7fffffff,0x78(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 12101b: e8 20 e9 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 121020: 31 d2 xor %edx,%edx <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 121022: 89 d0 mov %edx,%eax <== NOT EXECUTED 121024: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 121027: 5b pop %ebx <== NOT EXECUTED 121028: 5e pop %esi <== NOT EXECUTED 121029: 5f pop %edi <== NOT EXECUTED 12102a: c9 leave <== NOT EXECUTED 12102b: c3 ret <== NOT EXECUTED 00111908 : uint32_t length, uint32_t page_size, rtems_attribute attribute_set, Objects_Id *id ) { 111908: 55 push %ebp <== NOT EXECUTED 111909: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11190b: 57 push %edi <== NOT EXECUTED 11190c: 56 push %esi <== NOT EXECUTED 11190d: 53 push %ebx <== NOT EXECUTED 11190e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111911: 8b 7d 18 mov 0x18(%ebp),%edi <== NOT EXECUTED rtems_status_code return_status; Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 111914: be 03 00 00 00 mov $0x3,%esi <== NOT EXECUTED 111919: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 11191d: 0f 84 dc 00 00 00 je 1119ff <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !starting_address ) 111923: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 111927: 0f 84 cd 00 00 00 je 1119fa <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !id ) 11192d: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp) <== NOT EXECUTED 111931: 0f 84 c3 00 00 00 je 1119fa <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) 111937: f6 45 0c 03 testb $0x3,0xc(%ebp) <== NOT EXECUTED 11193b: 0f 85 b9 00 00 00 jne 1119fa <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 111941: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111944: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 11194a: e8 f5 1f 00 00 call 113944 <_API_Mutex_Lock> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 11194f: c7 04 24 94 26 13 00 movl $0x132694,(%esp) <== NOT EXECUTED 111956: e8 51 31 00 00 call 114aac <_Objects_Allocate> <== NOT EXECUTED 11195b: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_region = _Region_Allocate(); if ( !the_region ) 11195d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111960: be 05 00 00 00 mov $0x5,%esi <== NOT EXECUTED 111965: 85 c0 test %eax,%eax <== NOT EXECUTED 111967: 74 7e je 1119e7 <== NOT EXECUTED return_status = RTEMS_TOO_MANY; else { the_region->maximum_segment_size = _Heap_Initialize( 111969: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 11196c: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 11196f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111972: 8d 40 68 lea 0x68(%eax),%eax <== NOT EXECUTED 111975: 50 push %eax <== NOT EXECUTED 111976: e8 75 2c 00 00 call 1145f0 <_Heap_Initialize> <== NOT EXECUTED 11197b: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED &the_region->Memory, starting_address, length, page_size ); if ( !the_region->maximum_segment_size ) { 11197e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111981: 85 c0 test %eax,%eax <== NOT EXECUTED 111983: 75 14 jne 111999 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 111985: 50 push %eax <== NOT EXECUTED 111986: 50 push %eax <== NOT EXECUTED 111987: 53 push %ebx <== NOT EXECUTED 111988: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 11198d: e8 2a 34 00 00 call 114dbc <_Objects_Free> <== NOT EXECUTED 111992: be 08 00 00 00 mov $0x8,%esi <== NOT EXECUTED 111997: eb 4b jmp 1119e4 <== NOT EXECUTED return_status = RTEMS_INVALID_SIZE; } else { the_region->starting_address = starting_address; 111999: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11199c: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED the_region->length = length; 11199f: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1119a2: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED the_region->page_size = page_size; 1119a5: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1119a8: 89 43 58 mov %eax,0x58(%ebx) <== NOT EXECUTED the_region->attribute_set = attribute_set; 1119ab: 89 7b 60 mov %edi,0x60(%ebx) <== NOT EXECUTED the_region->number_of_used_blocks = 0; 1119ae: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) <== NOT EXECUTED _Thread_queue_Initialize( 1119b5: 6a 06 push $0x6 <== NOT EXECUTED 1119b7: 6a 40 push $0x40 <== NOT EXECUTED 1119b9: c1 ef 02 shr $0x2,%edi <== NOT EXECUTED 1119bc: 83 e7 01 and $0x1,%edi <== NOT EXECUTED 1119bf: 57 push %edi <== NOT EXECUTED 1119c0: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 1119c3: 50 push %eax <== NOT EXECUTED 1119c4: e8 a7 43 00 00 call 115d70 <_Thread_queue_Initialize> <== NOT EXECUTED 1119c9: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 1119cc: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 1119cf: a1 b0 26 13 00 mov 0x1326b0,%eax <== NOT EXECUTED 1119d4: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 1119d7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1119da: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 1119dd: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 1119e0: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 1119e2: 31 f6 xor %esi,%esi <== NOT EXECUTED 1119e4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return_status = RTEMS_SUCCESSFUL; } } _RTEMS_Unlock_allocator(); 1119e7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1119ea: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 1119f0: e8 97 1f 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED 1119f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1119f8: eb 05 jmp 1119ff <== NOT EXECUTED return return_status; 1119fa: be 09 00 00 00 mov $0x9,%esi <== NOT EXECUTED } 1119ff: 89 f0 mov %esi,%eax <== NOT EXECUTED 111a01: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111a04: 5b pop %ebx <== NOT EXECUTED 111a05: 5e pop %esi <== NOT EXECUTED 111a06: 5f pop %edi <== NOT EXECUTED 111a07: c9 leave <== NOT EXECUTED 111a08: c3 ret <== NOT EXECUTED 00111a0c : */ rtems_status_code rtems_region_delete( Objects_Id id ) { 111a0c: 55 push %ebp <== NOT EXECUTED 111a0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111a0f: 56 push %esi <== NOT EXECUTED 111a10: 53 push %ebx <== NOT EXECUTED 111a11: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; _RTEMS_Lock_allocator(); 111a14: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111a1a: e8 25 1f 00 00 call 113944 <_API_Mutex_Lock> <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 111a1f: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 111a22: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 111a25: 50 push %eax <== NOT EXECUTED 111a26: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111a29: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111a2e: e8 bd 34 00 00 call 114ef0 <_Objects_Get_no_protection> <== NOT EXECUTED 111a33: 89 c6 mov %eax,%esi <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 111a35: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111a38: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 111a3b: 85 c0 test %eax,%eax <== NOT EXECUTED 111a3d: 74 11 je 111a50 <== NOT EXECUTED 111a3f: 31 db xor %ebx,%ebx <== NOT EXECUTED 111a41: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 111a44: 0f 95 c3 setne %bl <== NOT EXECUTED 111a47: 4b dec %ebx <== NOT EXECUTED 111a48: 83 e3 eb and $0xffffffeb,%ebx <== NOT EXECUTED 111a4b: 83 c3 19 add $0x19,%ebx <== NOT EXECUTED 111a4e: eb 2a jmp 111a7a <== NOT EXECUTED case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks != 0 ) 111a50: bb 0c 00 00 00 mov $0xc,%ebx <== NOT EXECUTED 111a55: 83 7e 64 00 cmpl $0x0,0x64(%esi) <== NOT EXECUTED 111a59: 75 1f jne 111a7a <== NOT EXECUTED return_status = RTEMS_RESOURCE_IN_USE; else { _Objects_Close( &_Region_Information, &the_region->Object ); 111a5b: 51 push %ecx <== NOT EXECUTED 111a5c: 51 push %ecx <== NOT EXECUTED 111a5d: 56 push %esi <== NOT EXECUTED 111a5e: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111a63: e8 b8 30 00 00 call 114b20 <_Objects_Close> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 111a68: 58 pop %eax <== NOT EXECUTED 111a69: 5a pop %edx <== NOT EXECUTED 111a6a: 56 push %esi <== NOT EXECUTED 111a6b: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111a70: e8 47 33 00 00 call 114dbc <_Objects_Free> <== NOT EXECUTED 111a75: 31 db xor %ebx,%ebx <== NOT EXECUTED 111a77: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111a7a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111a7d: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111a83: e8 04 1f 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED return return_status; } 111a88: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111a8a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111a8d: 5b pop %ebx <== NOT EXECUTED 111a8e: 5e pop %esi <== NOT EXECUTED 111a8f: c9 leave <== NOT EXECUTED 111a90: c3 ret <== NOT EXECUTED 00111a94 : rtems_status_code rtems_region_extend( Objects_Id id, void *starting_address, uint32_t length ) { 111a94: 55 push %ebp <== NOT EXECUTED 111a95: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111a97: 57 push %edi <== NOT EXECUTED 111a98: 56 push %esi <== NOT EXECUTED 111a99: 53 push %ebx <== NOT EXECUTED 111a9a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 111a9d: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Heap_Extend_status heap_status; Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; Region_Control *the_region; if ( !starting_address ) 111aa0: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED 111aa5: 85 ff test %edi,%edi <== NOT EXECUTED 111aa7: 0f 84 82 00 00 00 je 111b2f <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 111aad: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111ab0: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111ab6: e8 89 1e 00 00 call 113944 <_API_Mutex_Lock> <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 111abb: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 111abe: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 111ac1: 50 push %eax <== NOT EXECUTED 111ac2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111ac5: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111aca: e8 21 34 00 00 call 114ef0 <_Objects_Get_no_protection> <== NOT EXECUTED 111acf: 89 c6 mov %eax,%esi <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 111ad1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111ad4: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 111ad7: 85 c0 test %eax,%eax <== NOT EXECUTED 111ad9: 74 08 je 111ae3 <== NOT EXECUTED 111adb: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 111ae0: 48 dec %eax <== NOT EXECUTED 111ae1: eb 25 jmp 111b08 <== NOT EXECUTED case OBJECTS_LOCAL: heap_status = _Heap_Extend( 111ae3: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 111ae6: 50 push %eax <== NOT EXECUTED 111ae7: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 111aea: 57 push %edi <== NOT EXECUTED 111aeb: 8d 46 68 lea 0x68(%esi),%eax <== NOT EXECUTED 111aee: 50 push %eax <== NOT EXECUTED 111aef: e8 4c 28 00 00 call 114340 <_Heap_Extend> <== NOT EXECUTED starting_address, length, &amount_extended ); switch ( heap_status ) { 111af4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111af7: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED 111afc: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 111aff: 74 1d je 111b1e <== NOT EXECUTED 111b01: 72 09 jb 111b0c <== NOT EXECUTED case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; the_region->maximum_segment_size += amount_extended; return_status = RTEMS_SUCCESSFUL; break; 111b03: b3 18 mov $0x18,%bl <== NOT EXECUTED starting_address, length, &amount_extended ); switch ( heap_status ) { 111b05: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 111b08: 75 0f jne 111b19 <== NOT EXECUTED 111b0a: eb 12 jmp 111b1e <== NOT EXECUTED case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 111b0c: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 111b0f: 01 46 54 add %eax,0x54(%esi) <== NOT EXECUTED the_region->maximum_segment_size += amount_extended; 111b12: 01 46 5c add %eax,0x5c(%esi) <== NOT EXECUTED 111b15: 31 db xor %ebx,%ebx <== NOT EXECUTED 111b17: eb 05 jmp 111b1e <== NOT EXECUTED return_status = RTEMS_SUCCESSFUL; break; 111b19: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111b1e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111b21: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111b27: e8 60 1e 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED 111b2c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 111b2f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111b31: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111b34: 5b pop %ebx <== NOT EXECUTED 111b35: 5e pop %esi <== NOT EXECUTED 111b36: 5f pop %edi <== NOT EXECUTED 111b37: c9 leave <== NOT EXECUTED 111b38: c3 ret <== NOT EXECUTED 00111b3c : rtems_status_code rtems_region_get_free_information( Objects_Id id, Heap_Information_block *the_info ) { 111b3c: 55 push %ebp <== NOT EXECUTED 111b3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111b3f: 56 push %esi <== NOT EXECUTED 111b40: 53 push %ebx <== NOT EXECUTED 111b41: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 111b44: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !the_info ) 111b47: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED 111b4c: 85 f6 test %esi,%esi <== NOT EXECUTED 111b4e: 74 74 je 111bc4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 111b50: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111b53: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111b59: e8 e6 1d 00 00 call 113944 <_API_Mutex_Lock> <== NOT EXECUTED 111b5e: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 111b61: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 111b64: 50 push %eax <== NOT EXECUTED 111b65: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111b68: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111b6d: e8 7e 33 00 00 call 114ef0 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 111b72: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111b75: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 111b78: 85 d2 test %edx,%edx <== NOT EXECUTED 111b7a: 74 11 je 111b8d <== NOT EXECUTED 111b7c: 31 db xor %ebx,%ebx <== NOT EXECUTED 111b7e: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 111b81: 0f 95 c3 setne %bl <== NOT EXECUTED 111b84: 4b dec %ebx <== NOT EXECUTED 111b85: 83 e3 eb and $0xffffffeb,%ebx <== NOT EXECUTED 111b88: 83 c3 19 add $0x19,%ebx <== NOT EXECUTED 111b8b: eb 26 jmp 111bb3 <== NOT EXECUTED case OBJECTS_LOCAL: the_info->Used.number = 0; 111b8d: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) <== NOT EXECUTED the_info->Used.total = 0; 111b94: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED the_info->Used.largest = 0; 111b9b: c7 46 10 00 00 00 00 movl $0x0,0x10(%esi) <== NOT EXECUTED _Heap_Get_free_information( &the_region->Memory, &the_info->Free ); 111ba2: 52 push %edx <== NOT EXECUTED 111ba3: 52 push %edx <== NOT EXECUTED 111ba4: 56 push %esi <== NOT EXECUTED 111ba5: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 111ba8: 50 push %eax <== NOT EXECUTED 111ba9: e8 82 29 00 00 call 114530 <_Heap_Get_free_information> <== NOT EXECUTED 111bae: 31 db xor %ebx,%ebx <== NOT EXECUTED 111bb0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111bb3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111bb6: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111bbc: e8 cb 1d 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED 111bc1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 111bc4: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111bc6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111bc9: 5b pop %ebx <== NOT EXECUTED 111bca: 5e pop %esi <== NOT EXECUTED 111bcb: c9 leave <== NOT EXECUTED 111bcc: c3 ret <== NOT EXECUTED 00111bd0 : rtems_status_code rtems_region_get_information( Objects_Id id, Heap_Information_block *the_info ) { 111bd0: 55 push %ebp <== NOT EXECUTED 111bd1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111bd3: 56 push %esi <== NOT EXECUTED 111bd4: 53 push %ebx <== NOT EXECUTED 111bd5: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 111bd8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !the_info ) 111bdb: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED 111be0: 85 f6 test %esi,%esi <== NOT EXECUTED 111be2: 74 67 je 111c4b <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 111be4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111be7: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111bed: e8 52 1d 00 00 call 113944 <_API_Mutex_Lock> <== NOT EXECUTED 111bf2: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 111bf5: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 111bf8: 50 push %eax <== NOT EXECUTED 111bf9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111bfc: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111c01: e8 ea 32 00 00 call 114ef0 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 111c06: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111c09: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 111c0c: 85 d2 test %edx,%edx <== NOT EXECUTED 111c0e: 74 11 je 111c21 <== NOT EXECUTED 111c10: 31 db xor %ebx,%ebx <== NOT EXECUTED 111c12: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 111c15: 0f 95 c3 setne %bl <== NOT EXECUTED 111c18: 4b dec %ebx <== NOT EXECUTED 111c19: 83 e3 eb and $0xffffffeb,%ebx <== NOT EXECUTED 111c1c: 83 c3 19 add $0x19,%ebx <== NOT EXECUTED 111c1f: eb 19 jmp 111c3a <== NOT EXECUTED case OBJECTS_LOCAL: if ( _Heap_Get_information( &the_region->Memory, the_info ) != 111c21: 52 push %edx <== NOT EXECUTED 111c22: 52 push %edx <== NOT EXECUTED 111c23: 56 push %esi <== NOT EXECUTED 111c24: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 111c27: 50 push %eax <== NOT EXECUTED 111c28: e8 43 29 00 00 call 114570 <_Heap_Get_information> <== NOT EXECUTED 111c2d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111c30: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 111c33: 19 db sbb %ebx,%ebx <== NOT EXECUTED 111c35: f7 d3 not %ebx <== NOT EXECUTED 111c37: 83 e3 09 and $0x9,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111c3a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111c3d: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111c43: e8 44 1d 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED 111c48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 111c4b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111c4d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111c50: 5b pop %ebx <== NOT EXECUTED 111c51: 5e pop %esi <== NOT EXECUTED 111c52: c9 leave <== NOT EXECUTED 111c53: c3 ret <== NOT EXECUTED 00111c54 : uint32_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 111c54: 55 push %ebp <== NOT EXECUTED 111c55: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111c57: 57 push %edi <== NOT EXECUTED 111c58: 56 push %esi <== NOT EXECUTED 111c59: 53 push %ebx <== NOT EXECUTED 111c5a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; void *the_segment; if ( !segment ) 111c5d: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED 111c62: 83 7d 18 00 cmpl $0x0,0x18(%ebp) <== NOT EXECUTED 111c66: 0f 84 fd 00 00 00 je 111d69 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; *segment = NULL; 111c6c: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 111c6f: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED if ( size == 0 ) 111c75: bb 08 00 00 00 mov $0x8,%ebx <== NOT EXECUTED 111c7a: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 111c7e: 0f 84 e5 00 00 00 je 111d69 <== NOT EXECUTED return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 111c84: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111c87: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111c8d: e8 b2 1c 00 00 call 113944 <_API_Mutex_Lock> <== NOT EXECUTED executing = _Thread_Executing; 111c92: 8b 3d a0 28 13 00 mov 0x1328a0,%edi <== NOT EXECUTED 111c98: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 111c9b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 111c9e: 50 push %eax <== NOT EXECUTED 111c9f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111ca2: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111ca7: e8 44 32 00 00 call 114ef0 <_Objects_Get_no_protection> <== NOT EXECUTED 111cac: 89 c6 mov %eax,%esi <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 111cae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111cb1: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 111cb4: 85 c0 test %eax,%eax <== NOT EXECUTED 111cb6: 74 14 je 111ccc <== NOT EXECUTED 111cb8: 31 db xor %ebx,%ebx <== NOT EXECUTED 111cba: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 111cbd: 0f 95 c3 setne %bl <== NOT EXECUTED 111cc0: 4b dec %ebx <== NOT EXECUTED 111cc1: 83 e3 eb and $0xffffffeb,%ebx <== NOT EXECUTED 111cc4: 83 c3 19 add $0x19,%ebx <== NOT EXECUTED 111cc7: e9 8c 00 00 00 jmp 111d58 <== NOT EXECUTED case OBJECTS_LOCAL: if ( size > the_region->maximum_segment_size ) 111ccc: bb 08 00 00 00 mov $0x8,%ebx <== NOT EXECUTED 111cd1: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 111cd4: 3b 56 5c cmp 0x5c(%esi),%edx <== NOT EXECUTED 111cd7: 77 7f ja 111d58 <== NOT EXECUTED /** * This function attempts to allocate a block of @a size bytes from * @a the_heap. If insufficient memory is free in @a the_heap to allocate * a block of the requested size, then NULL is returned. * 111cd9: 50 push %eax <== NOT EXECUTED 111cda: 50 push %eax <== NOT EXECUTED 111cdb: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111cde: 8d 46 68 lea 0x68(%esi),%eax <== NOT EXECUTED 111ce1: 50 push %eax <== NOT EXECUTED 111ce2: e8 ed 25 00 00 call 1142d4 <_Heap_Allocate> <== NOT EXECUTED the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 111ce7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111cea: 85 c0 test %eax,%eax <== NOT EXECUTED 111cec: 74 0c je 111cfa <== NOT EXECUTED the_region->number_of_used_blocks += 1; 111cee: ff 46 64 incl 0x64(%esi) <== NOT EXECUTED *segment = the_segment; 111cf1: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 111cf4: 89 02 mov %eax,(%edx) <== NOT EXECUTED 111cf6: 31 db xor %ebx,%ebx <== NOT EXECUTED 111cf8: eb 5e jmp 111d58 <== NOT EXECUTED return_status = RTEMS_SUCCESSFUL; } else if ( _Options_Is_no_wait( option_set ) ) { 111cfa: bb 0d 00 00 00 mov $0xd,%ebx <== NOT EXECUTED 111cff: f6 45 10 01 testb $0x1,0x10(%ebp) <== NOT EXECUTED 111d03: 75 53 jne 111d58 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 111d05: a1 e0 27 13 00 mov 0x1327e0,%eax <== NOT EXECUTED 111d0a: 40 inc %eax <== NOT EXECUTED 111d0b: a3 e0 27 13 00 mov %eax,0x1327e0 <== NOT EXECUTED * Switch from using the memory allocation mutex to using a * dispatching disabled critical section. We have to do this * because this thread is going to block. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); 111d10: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111d13: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111d19: e8 6e 1c 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED executing->Wait.queue = &the_region->Wait_queue; 111d1e: 8d 46 10 lea 0x10(%esi),%eax <== NOT EXECUTED 111d21: 89 47 44 mov %eax,0x44(%edi) <== NOT EXECUTED executing->Wait.id = id; 111d24: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 111d27: 89 57 20 mov %edx,0x20(%edi) <== NOT EXECUTED executing->Wait.count = size; 111d2a: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 111d2d: 89 57 24 mov %edx,0x24(%edi) <== NOT EXECUTED executing->Wait.return_argument = segment; 111d30: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 111d33: 89 57 28 mov %edx,0x28(%edi) <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 111d36: c7 46 40 01 00 00 00 movl $0x1,0x40(%esi) <== NOT EXECUTED _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 111d3d: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 111d40: 68 40 5e 11 00 push $0x115e40 <== NOT EXECUTED 111d45: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 111d48: 50 push %eax <== NOT EXECUTED 111d49: e8 ee 3d 00 00 call 115b3c <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 111d4e: e8 99 39 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED return (rtems_status_code) executing->Wait.return_code; 111d53: 8b 5f 34 mov 0x34(%edi),%ebx <== NOT EXECUTED 111d56: eb 0e jmp 111d66 <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111d58: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111d5b: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111d61: e8 26 1c 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED 111d66: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 111d69: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111d6b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111d6e: 5b pop %ebx <== NOT EXECUTED 111d6f: 5e pop %esi <== NOT EXECUTED 111d70: 5f pop %edi <== NOT EXECUTED 111d71: c9 leave <== NOT EXECUTED 111d72: c3 ret <== NOT EXECUTED 00111d74 : rtems_status_code rtems_region_get_segment_size( Objects_Id id, void *segment, size_t *size ) { 111d74: 55 push %ebp <== NOT EXECUTED 111d75: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111d77: 56 push %esi <== NOT EXECUTED 111d78: 53 push %ebx <== NOT EXECUTED 111d79: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 111d7c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 111d7f: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !segment ) 111d82: 85 f6 test %esi,%esi <== NOT EXECUTED 111d84: 74 6a je 111df0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !size ) 111d86: 85 db test %ebx,%ebx <== NOT EXECUTED 111d88: 74 66 je 111df0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 111d8a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111d8d: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111d93: e8 ac 1b 00 00 call 113944 <_API_Mutex_Lock> <== NOT EXECUTED * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 111d98: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 111d9b: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 111d9e: 50 push %eax <== NOT EXECUTED 111d9f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111da2: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111da7: e8 44 31 00 00 call 114ef0 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 111dac: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111daf: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 111db2: 85 d2 test %edx,%edx <== NOT EXECUTED 111db4: 74 11 je 111dc7 <== NOT EXECUTED 111db6: 31 db xor %ebx,%ebx <== NOT EXECUTED 111db8: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 111dbb: 0f 95 c3 setne %bl <== NOT EXECUTED 111dbe: 4b dec %ebx <== NOT EXECUTED 111dbf: 83 e3 eb and $0xffffffeb,%ebx <== NOT EXECUTED 111dc2: 83 c3 19 add $0x19,%ebx <== NOT EXECUTED 111dc5: eb 16 jmp 111ddd <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Heap_Size_of_user_area( &the_region->Memory, segment, size ) ) 111dc7: 52 push %edx <== NOT EXECUTED 111dc8: 53 push %ebx <== NOT EXECUTED 111dc9: 56 push %esi <== NOT EXECUTED 111dca: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 111dcd: 50 push %eax <== NOT EXECUTED 111dce: e8 d5 2b 00 00 call 1149a8 <_Heap_Size_of_user_area> <== NOT EXECUTED 111dd3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111dd6: 3c 01 cmp $0x1,%al <== NOT EXECUTED 111dd8: 19 db sbb %ebx,%ebx <== NOT EXECUTED 111dda: 83 e3 09 and $0x9,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111ddd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111de0: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111de6: e8 a1 1b 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED 111deb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111dee: eb 05 jmp 111df5 <== NOT EXECUTED return return_status; 111df0: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED } 111df5: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111df7: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111dfa: 5b pop %ebx <== NOT EXECUTED 111dfb: 5e pop %esi <== NOT EXECUTED 111dfc: c9 leave <== NOT EXECUTED 111dfd: c3 ret <== NOT EXECUTED 00111e00 : rtems_status_code rtems_region_ident( rtems_name name, Objects_Id *id ) { 111e00: 55 push %ebp <== NOT EXECUTED 111e01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111e03: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 111e06: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111e09: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 111e0e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111e11: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111e16: e8 59 32 00 00 call 115074 <_Objects_Name_to_id_u32> <== NOT EXECUTED 111e1b: 8b 04 85 58 7f 12 00 mov 0x127f58(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 111e22: c9 leave <== NOT EXECUTED 111e23: c3 ret <== NOT EXECUTED 00111e24 : Objects_Id id, void *segment, size_t size, size_t *old_size ) { 111e24: 55 push %ebp <== NOT EXECUTED 111e25: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111e27: 57 push %edi <== NOT EXECUTED 111e28: 56 push %esi <== NOT EXECUTED 111e29: 53 push %ebx <== NOT EXECUTED 111e2a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 111e2d: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED uint32_t osize; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; Heap_Resize_status status; register Region_Control *the_region; if ( !old_size ) 111e30: 85 ff test %edi,%edi <== NOT EXECUTED 111e32: 0f 84 aa 00 00 00 je 111ee2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 111e38: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111e3b: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111e41: e8 fe 1a 00 00 call 113944 <_API_Mutex_Lock> <== NOT EXECUTED 111e46: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 111e49: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 111e4c: 50 push %eax <== NOT EXECUTED 111e4d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111e50: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111e55: e8 96 30 00 00 call 114ef0 <_Objects_Get_no_protection> <== NOT EXECUTED 111e5a: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 111e5c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111e5f: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 111e62: 85 c0 test %eax,%eax <== NOT EXECUTED 111e64: 74 1f je 111e85 <== NOT EXECUTED 111e66: 31 db xor %ebx,%ebx <== NOT EXECUTED 111e68: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 111e6b: 0f 95 c3 setne %bl <== NOT EXECUTED 111e6e: 4b dec %ebx <== NOT EXECUTED 111e6f: 83 e3 eb and $0xffffffeb,%ebx <== NOT EXECUTED 111e72: 83 c3 19 add $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111e75: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111e78: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111e7e: e8 09 1b 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED 111e83: eb 39 jmp 111ebe <== NOT EXECUTED case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 7 ); status = _Heap_Resize_block( 111e85: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111e88: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 111e8b: 50 push %eax <== NOT EXECUTED 111e8c: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 111e8f: 50 push %eax <== NOT EXECUTED 111e90: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 111e93: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111e96: 8d 43 68 lea 0x68(%ebx),%eax <== NOT EXECUTED 111e99: 50 push %eax <== NOT EXECUTED 111e9a: e8 19 29 00 00 call 1147b8 <_Heap_Resize_block> <== NOT EXECUTED 111e9f: 89 c6 mov %eax,%esi <== NOT EXECUTED segment, (uint32_t) size, &osize, &avail_size ); *old_size = (uint32_t) osize; 111ea1: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 111ea4: 89 07 mov %eax,(%edi) <== NOT EXECUTED _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 ) 111ea6: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 111ea9: 85 f6 test %esi,%esi <== NOT EXECUTED 111eab: 75 16 jne 111ec3 <== NOT EXECUTED 111ead: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 111eb1: 74 10 je 111ec3 <== NOT EXECUTED _Region_Process_queue( the_region ); /* unlocks allocator */ 111eb3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111eb6: 53 push %ebx <== NOT EXECUTED 111eb7: e8 c4 61 00 00 call 118080 <_Region_Process_queue> <== NOT EXECUTED 111ebc: 31 db xor %ebx,%ebx <== NOT EXECUTED 111ebe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111ec1: eb 24 jmp 111ee7 <== NOT EXECUTED else _RTEMS_Unlock_allocator(); 111ec3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111ec6: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111ecc: e8 bb 1a 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED return 111ed1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111ed4: 31 db xor %ebx,%ebx <== NOT EXECUTED 111ed6: 85 f6 test %esi,%esi <== NOT EXECUTED 111ed8: 74 0d je 111ee7 <== NOT EXECUTED 111eda: bb 0d 00 00 00 mov $0xd,%ebx <== NOT EXECUTED 111edf: 4e dec %esi <== NOT EXECUTED 111ee0: 74 05 je 111ee7 <== NOT EXECUTED return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); return return_status; 111ee2: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED } 111ee7: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111ee9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111eec: 5b pop %ebx <== NOT EXECUTED 111eed: 5e pop %esi <== NOT EXECUTED 111eee: 5f pop %edi <== NOT EXECUTED 111eef: c9 leave <== NOT EXECUTED 111ef0: c3 ret <== NOT EXECUTED 00111ef4 : rtems_status_code rtems_region_return_segment( Objects_Id id, void *segment ) { 111ef4: 55 push %ebp <== NOT EXECUTED 111ef5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111ef7: 56 push %esi <== NOT EXECUTED 111ef8: 53 push %ebx <== NOT EXECUTED 111ef9: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED uint32_t size; #endif int status; register Region_Control *the_region; _RTEMS_Lock_allocator(); 111efc: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111f02: e8 3d 1a 00 00 call 113944 <_API_Mutex_Lock> <== NOT EXECUTED 111f07: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 111f0a: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 111f0d: 50 push %eax <== NOT EXECUTED 111f0e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111f11: 68 94 26 13 00 push $0x132694 <== NOT EXECUTED 111f16: e8 d5 2f 00 00 call 114ef0 <_Objects_Get_no_protection> <== NOT EXECUTED 111f1b: 89 c6 mov %eax,%esi <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 111f1d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111f20: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 111f23: 85 c0 test %eax,%eax <== NOT EXECUTED 111f25: 74 11 je 111f38 <== NOT EXECUTED 111f27: 31 db xor %ebx,%ebx <== NOT EXECUTED 111f29: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 111f2c: 0f 95 c3 setne %bl <== NOT EXECUTED 111f2f: 4b dec %ebx <== NOT EXECUTED 111f30: 83 e3 eb and $0xffffffeb,%ebx <== NOT EXECUTED 111f33: 83 c3 19 add $0x19,%ebx <== NOT EXECUTED 111f36: eb 2a jmp 111f62 <== NOT EXECUTED ); /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. 111f38: 50 push %eax <== NOT EXECUTED 111f39: 50 push %eax <== NOT EXECUTED 111f3a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111f3d: 8d 46 68 lea 0x68(%esi),%eax <== NOT EXECUTED 111f40: 50 push %eax <== NOT EXECUTED 111f41: e8 82 24 00 00 call 1143c8 <_Heap_Free> <== NOT EXECUTED #endif status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) 111f46: 83 c4 10 add $0x10,%esp <== NOT EXECUTED else { the_region->number_of_used_blocks -= 1; _Region_Process_queue(the_region); /* unlocks allocator */ return RTEMS_SUCCESSFUL; 111f49: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED #endif status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) 111f4e: 84 c0 test %al,%al <== NOT EXECUTED 111f50: 74 10 je 111f62 <== NOT EXECUTED return_status = RTEMS_INVALID_ADDRESS; else { the_region->number_of_used_blocks -= 1; 111f52: ff 4e 64 decl 0x64(%esi) <== NOT EXECUTED _Region_Process_queue(the_region); /* unlocks allocator */ 111f55: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111f58: 56 push %esi <== NOT EXECUTED 111f59: e8 22 61 00 00 call 118080 <_Region_Process_queue> <== NOT EXECUTED 111f5e: 30 db xor %bl,%bl <== NOT EXECUTED 111f60: eb 0e jmp 111f70 <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111f62: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111f65: ff 35 98 28 13 00 pushl 0x132898 <== NOT EXECUTED 111f6b: e8 1c 1a 00 00 call 11398c <_API_Mutex_Unlock> <== NOT EXECUTED 111f70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 111f73: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111f75: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111f78: 5b pop %ebx <== NOT EXECUTED 111f79: 5e pop %esi <== NOT EXECUTED 111f7a: c9 leave <== NOT EXECUTED 111f7b: c3 ret <== NOT EXECUTED 00108f14 : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 108f14: 55 push %ebp <== NOT EXECUTED 108f15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108f17: 57 push %edi <== NOT EXECUTED 108f18: 56 push %esi <== NOT EXECUTED 108f19: 53 push %ebx <== NOT EXECUTED 108f1a: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 108f1d: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED register Semaphore_Control *the_semaphore; CORE_mutex_Attributes the_mutex_attributes; CORE_semaphore_Attributes the_semaphore_attributes; if ( !rtems_is_name_valid( name ) ) 108f20: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 108f25: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 108f29: 0f 84 7f 01 00 00 je 1090ae <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 108f2f: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 108f34: 83 7d 18 00 cmpl $0x0,0x18(%ebp) <== NOT EXECUTED 108f38: 0f 84 70 01 00 00 je 1090ae <== NOT EXECUTED return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 108f3e: 89 da mov %ebx,%edx <== NOT EXECUTED 108f40: 81 e2 c0 00 00 00 and $0xc0,%edx <== NOT EXECUTED 108f46: 74 28 je 108f70 <== NOT EXECUTED * @param[in] alignment the required alignment * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, 108f48: 89 d8 mov %ebx,%eax <== NOT EXECUTED 108f4a: 83 e0 30 and $0x30,%eax <== NOT EXECUTED _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 108f4d: 83 f8 10 cmp $0x10,%eax <== NOT EXECUTED 108f50: 74 09 je 108f5b <== NOT EXECUTED 108f52: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED 108f55: 0f 85 4e 01 00 00 jne 1090a9 <== NOT EXECUTED 108f5b: f6 c3 04 test $0x4,%bl <== NOT EXECUTED 108f5e: 0f 84 45 01 00 00 je 1090a9 <== NOT EXECUTED _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 108f64: 81 fa c0 00 00 00 cmp $0xc0,%edx <== NOT EXECUTED 108f6a: 0f 84 39 01 00 00 je 1090a9 <== NOT EXECUTED _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) ) 108f70: 89 df mov %ebx,%edi <== NOT EXECUTED 108f72: 83 e7 30 and $0x30,%edi <== NOT EXECUTED 108f75: 74 0f je 108f86 <== NOT EXECUTED 108f77: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 108f7c: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 108f80: 0f 87 28 01 00 00 ja 1090ae <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 108f86: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 108f8b: 40 inc %eax <== NOT EXECUTED 108f8c: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 108f91: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108f94: 68 48 c9 11 00 push $0x11c948 <== NOT EXECUTED 108f99: e8 1e 12 00 00 call 10a1bc <_Objects_Allocate> <== NOT EXECUTED 108f9e: 89 c6 mov %eax,%esi <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 108fa0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108fa3: 85 c0 test %eax,%eax <== NOT EXECUTED 108fa5: 75 0f jne 108fb6 <== NOT EXECUTED _Thread_Enable_dispatch(); 108fa7: e8 14 1e 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 108fac: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 108fb1: e9 f8 00 00 00 jmp 1090ae <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_semaphore->attribute_set = attribute_set; 108fb6: 89 58 10 mov %ebx,0x10(%eax) <== NOT EXECUTED * If it is not a counting semaphore, then it is either a * simple binary semaphore or a more powerful mutex style binary * semaphore. */ if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) { 108fb9: 85 ff test %edi,%edi <== NOT EXECUTED 108fbb: 0f 84 92 00 00 00 je 109053 <== NOT EXECUTED CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) 108fc1: f6 c3 40 test $0x40,%bl <== NOT EXECUTED 108fc4: 74 09 je 108fcf <== NOT EXECUTED the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 108fc6: c7 45 e4 02 00 00 00 movl $0x2,-0x1c(%ebp) <== NOT EXECUTED 108fcd: eb 18 jmp 108fe7 <== NOT EXECUTED else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) 108fcf: 84 db test %bl,%bl <== NOT EXECUTED 108fd1: 79 09 jns 108fdc <== NOT EXECUTED the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 108fd3: c7 45 e4 03 00 00 00 movl $0x3,-0x1c(%ebp) <== NOT EXECUTED 108fda: eb 0b jmp 108fe7 <== NOT EXECUTED else if ( _Attributes_Is_priority( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; 108fdc: 31 c0 xor %eax,%eax <== NOT EXECUTED 108fde: f6 c3 04 test $0x4,%bl <== NOT EXECUTED 108fe1: 0f 95 c0 setne %al <== NOT EXECUTED 108fe4: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED else the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 108fe7: 83 ff 10 cmp $0x10,%edi <== NOT EXECUTED 108fea: 75 1a jne 109006 <== NOT EXECUTED the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 108fec: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED switch ( the_mutex_attributes.discipline ) { 108ff3: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 108ff6: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 108ff9: 76 12 jbe 10900d <== NOT EXECUTED 108ffb: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 108ffe: 77 11 ja 109011 <== NOT EXECUTED case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_mutex_attributes.only_owner_release = TRUE; 109000: c6 45 e0 01 movb $0x1,-0x20(%ebp) <== NOT EXECUTED 109004: eb 0b jmp 109011 <== NOT EXECUTED break; } } else { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS; 109006: c7 45 dc 02 00 00 00 movl $0x2,-0x24(%ebp) <== NOT EXECUTED the_mutex_attributes.only_owner_release = FALSE; 10900d: c6 45 e0 00 movb $0x0,-0x20(%ebp) <== NOT EXECUTED } the_mutex_attributes.priority_ceiling = priority_ceiling; 109011: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 109014: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED mutex_status = _CORE_mutex_Initialize( 109017: 51 push %ecx <== NOT EXECUTED 109018: 31 c0 xor %eax,%eax <== NOT EXECUTED 10901a: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10901e: 0f 94 c0 sete %al <== NOT EXECUTED 109021: 50 push %eax <== NOT EXECUTED 109022: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 109025: 50 push %eax <== NOT EXECUTED 109026: 8d 46 14 lea 0x14(%esi),%eax <== NOT EXECUTED 109029: 50 push %eax <== NOT EXECUTED 10902a: e8 4d 0b 00 00 call 109b7c <_CORE_mutex_Initialize> <== NOT EXECUTED &the_semaphore->Core_control.mutex, &the_mutex_attributes, (count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED ); if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) { 10902f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109032: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 109035: 75 50 jne 109087 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 109037: 52 push %edx <== NOT EXECUTED 109038: 52 push %edx <== NOT EXECUTED 109039: 56 push %esi <== NOT EXECUTED 10903a: 68 48 c9 11 00 push $0x11c948 <== NOT EXECUTED 10903f: e8 88 14 00 00 call 10a4cc <_Objects_Free> <== NOT EXECUTED _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 109044: e8 77 1d 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 109049: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED 10904e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109051: eb 5b jmp 1090ae <== NOT EXECUTED return RTEMS_INVALID_PRIORITY; } } else { if ( _Attributes_Is_priority( attribute_set ) ) the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 109053: 31 c0 xor %eax,%eax <== NOT EXECUTED 109055: f6 c3 04 test $0x4,%bl <== NOT EXECUTED 109058: 0f 95 c0 setne %al <== NOT EXECUTED 10905b: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 10905e: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp) <== NOT EXECUTED /* * The following are just to make Purify happy. */ the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 109065: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM; 10906c: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp) <== NOT EXECUTED _CORE_semaphore_Initialize( 109073: 50 push %eax <== NOT EXECUTED 109074: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109077: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10907a: 50 push %eax <== NOT EXECUTED 10907b: 8d 46 14 lea 0x14(%esi),%eax <== NOT EXECUTED 10907e: 50 push %eax <== NOT EXECUTED 10907f: e8 74 0d 00 00 call 109df8 <_CORE_semaphore_Initialize> <== NOT EXECUTED 109084: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109087: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED 10908a: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10908d: a1 64 c9 11 00 mov 0x11c964,%eax <== NOT EXECUTED 109092: 89 34 90 mov %esi,(%eax,%edx,4) <== NOT EXECUTED 109095: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109098: 89 46 0c mov %eax,0xc(%esi) <== NOT EXECUTED &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 10909b: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10909e: 89 08 mov %ecx,(%eax) <== NOT EXECUTED the_semaphore->Object.id, name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 1090a0: e8 1b 1d 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 1090a5: 31 c0 xor %eax,%eax <== NOT EXECUTED 1090a7: eb 05 jmp 1090ae <== NOT EXECUTED return RTEMS_SUCCESSFUL; 1090a9: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED } 1090ae: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1090b1: 5b pop %ebx <== NOT EXECUTED 1090b2: 5e pop %esi <== NOT EXECUTED 1090b3: 5f pop %edi <== NOT EXECUTED 1090b4: c9 leave <== NOT EXECUTED 1090b5: c3 ret <== NOT EXECUTED 001090b8 : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 1090b8: 55 push %ebp <== NOT EXECUTED 1090b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1090bb: 53 push %ebx <== NOT EXECUTED 1090bc: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap 1090bf: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1090c2: 50 push %eax <== NOT EXECUTED 1090c3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1090c6: 68 48 c9 11 00 push $0x11c948 <== NOT EXECUTED 1090cb: e8 30 15 00 00 call 10a600 <_Objects_Get> <== NOT EXECUTED 1090d0: 89 c3 mov %eax,%ebx <== NOT EXECUTED register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 1090d2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1090d5: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1090da: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 1090de: 75 61 jne 109141 <== NOT EXECUTED ); /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. * 1090e0: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 1090e3: 83 e0 30 and $0x30,%eax <== NOT EXECUTED 1090e6: 74 27 je 10910f <== NOT EXECUTED if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 1090e8: 83 7b 64 00 cmpl $0x0,0x64(%ebx) <== NOT EXECUTED 1090ec: 75 11 jne 1090ff <== NOT EXECUTED 1090ee: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED 1090f1: 74 0c je 1090ff <== NOT EXECUTED !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); 1090f3: e8 c8 1c 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 1090f8: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED 1090fd: eb 42 jmp 109141 <== NOT EXECUTED return RTEMS_RESOURCE_IN_USE; } _CORE_mutex_Flush( 1090ff: 50 push %eax <== NOT EXECUTED 109100: 6a 04 push $0x4 <== NOT EXECUTED 109102: 6a 00 push $0x0 <== NOT EXECUTED 109104: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 109107: 50 push %eax <== NOT EXECUTED 109108: e8 63 0a 00 00 call 109b70 <_CORE_mutex_Flush> <== NOT EXECUTED 10910d: eb 0e jmp 10911d <== NOT EXECUTED &the_semaphore->Core_control.mutex, SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_MUTEX_WAS_DELETED ); } else { _CORE_semaphore_Flush( 10910f: 50 push %eax <== NOT EXECUTED 109110: 6a 02 push $0x2 <== NOT EXECUTED 109112: 6a 00 push $0x0 <== NOT EXECUTED 109114: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 109117: 50 push %eax <== NOT EXECUTED 109118: e8 cf 0c 00 00 call 109dec <_CORE_semaphore_Flush> <== NOT EXECUTED 10911d: 59 pop %ecx <== NOT EXECUTED 10911e: 58 pop %eax <== NOT EXECUTED SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_SEMAPHORE_WAS_DELETED ); } _Objects_Close( &_Semaphore_Information, &the_semaphore->Object ); 10911f: 53 push %ebx <== NOT EXECUTED 109120: 68 48 c9 11 00 push $0x11c948 <== NOT EXECUTED 109125: e8 06 11 00 00 call 10a230 <_Objects_Close> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 10912a: 58 pop %eax <== NOT EXECUTED 10912b: 5a pop %edx <== NOT EXECUTED 10912c: 53 push %ebx <== NOT EXECUTED 10912d: 68 48 c9 11 00 push $0x11c948 <== NOT EXECUTED 109132: e8 95 13 00 00 call 10a4cc <_Objects_Free> <== NOT EXECUTED 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 109137: e8 84 1c 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10913c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10913e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 109141: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109144: c9 leave <== NOT EXECUTED 109145: c3 ret <== NOT EXECUTED 0012108c : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 12108c: 55 push %ebp <== NOT EXECUTED 12108d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12108f: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED * to add to the heap 121092: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 121095: 50 push %eax <== NOT EXECUTED 121096: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 121099: 68 3c 9b 15 00 push $0x159b3c <== NOT EXECUTED 12109e: e8 2d e0 fe ff call 10f0d0 <_Objects_Get> <== NOT EXECUTED 1210a3: 89 c2 mov %eax,%edx <== NOT EXECUTED register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 1210a5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1210a8: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1210ad: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 1210b1: 75 2b jne 1210de <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 1210b3: f6 42 10 30 testb $0x30,0x10(%edx) <== NOT EXECUTED 1210b7: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 1210ba: 74 0d je 1210c9 <== NOT EXECUTED _CORE_mutex_Flush( 1210bc: 51 push %ecx <== NOT EXECUTED 1210bd: 6a 01 push $0x1 <== NOT EXECUTED 1210bf: 6a 00 push $0x0 <== NOT EXECUTED 1210c1: 50 push %eax <== NOT EXECUTED 1210c2: e8 49 d4 fe ff call 10e510 <_CORE_mutex_Flush> <== NOT EXECUTED 1210c7: eb 0b jmp 1210d4 <== NOT EXECUTED &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 1210c9: 52 push %edx <== NOT EXECUTED 1210ca: 6a 01 push $0x1 <== NOT EXECUTED 1210cc: 6a 00 push $0x0 <== NOT EXECUTED 1210ce: 50 push %eax <== NOT EXECUTED 1210cf: e8 b8 d6 fe ff call 10e78c <_CORE_semaphore_Flush> <== NOT EXECUTED 1210d4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &the_semaphore->Core_control.semaphore, SEND_OBJECT_WAS_DELETED, CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT ); } _Thread_Enable_dispatch(); 1210d7: e8 64 e8 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 1210dc: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1210de: c9 leave <== NOT EXECUTED 1210df: c3 ret <== NOT EXECUTED 00112204 : rtems_status_code rtems_semaphore_ident( rtems_name name, uint32_t node, rtems_id *id ) { 112204: 55 push %ebp <== NOT EXECUTED 112205: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112207: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( &_Semaphore_Information, name, node, id ); 11220a: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 11220d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 112210: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112213: 68 d4 26 13 00 push $0x1326d4 <== NOT EXECUTED 112218: e8 57 2e 00 00 call 115074 <_Objects_Name_to_id_u32> <== NOT EXECUTED 11221d: 8b 04 85 58 7f 12 00 mov 0x127f58(,%eax,4),%eax <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; } 112224: c9 leave <== NOT EXECUTED 112225: c3 ret <== NOT EXECUTED 00109148 : rtems_status_code rtems_semaphore_obtain( rtems_id id, rtems_option option_set, rtems_interval timeout ) { 109148: 55 push %ebp <== NOT EXECUTED 109149: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10914b: 57 push %edi <== NOT EXECUTED 10914c: 56 push %esi <== NOT EXECUTED 10914d: 53 push %ebx <== NOT EXECUTED 10914e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 109151: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 109154: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size 109157: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10915a: 50 push %eax <== NOT EXECUTED 10915b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10915e: 50 push %eax <== NOT EXECUTED 10915f: 57 push %edi <== NOT EXECUTED 109160: 68 48 c9 11 00 push $0x11c948 <== NOT EXECUTED 109165: e8 4a 14 00 00 call 10a5b4 <_Objects_Get_isr_disable> <== NOT EXECUTED 10916a: 89 c1 mov %eax,%ecx <== NOT EXECUTED register Semaphore_Control *the_semaphore; Objects_Locations location; ISR_Level level; the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); switch ( location ) { 10916c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10916f: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 109174: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 109178: 0f 85 a8 00 00 00 jne 109226 <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 10917e: f6 41 10 30 testb $0x30,0x10(%ecx) <== NOT EXECUTED 109182: 74 2c je 1091b0 <== NOT EXECUTED _CORE_mutex_Seize( 109184: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109187: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10918a: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10918d: 83 f3 01 xor $0x1,%ebx <== NOT EXECUTED 109190: 83 e3 01 and $0x1,%ebx <== NOT EXECUTED 109193: 53 push %ebx <== NOT EXECUTED 109194: 57 push %edi <== NOT EXECUTED 109195: 8d 41 14 lea 0x14(%ecx),%eax <== NOT EXECUTED 109198: 50 push %eax <== NOT EXECUTED 109199: e8 ca 0a 00 00 call 109c68 <_CORE_mutex_Seize> <== NOT EXECUTED id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 10919e: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 1091a1: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 1091a6: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 1091a9: e8 f2 00 00 00 call 1092a0 <_Semaphore_Translate_core_mutex_return_code> <== NOT EXECUTED 1091ae: eb 73 jmp 109223 <== NOT EXECUTED /** * This function attempts to allocate a block of @a size bytes from * @a the_heap. If insufficient memory is free in @a the_heap to allocate * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon 1091b0: 8b 75 ec mov -0x14(%ebp),%esi <== NOT EXECUTED * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate( 1091b3: 8b 15 c0 ca 11 00 mov 0x11cac0,%edx <== NOT EXECUTED Heap_Control *the_heap, 1091b9: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED size_t size 1091c0: 8b 41 5c mov 0x5c(%ecx),%eax <== NOT EXECUTED 1091c3: 85 c0 test %eax,%eax <== NOT EXECUTED 1091c5: 74 08 je 1091cf <== NOT EXECUTED ); 1091c7: 48 dec %eax <== NOT EXECUTED 1091c8: 89 41 5c mov %eax,0x5c(%ecx) <== NOT EXECUTED 1091cb: 56 push %esi <== NOT EXECUTED 1091cc: 9d popf <== NOT EXECUTED 1091cd: eb 44 jmp 109213 <== NOT EXECUTED /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. 1091cf: 80 e3 01 and $0x1,%bl <== NOT EXECUTED 1091d2: 74 0b je 1091df <== NOT EXECUTED * Any other value of @a alignment is taken "as is", i.e., even odd 1091d4: 56 push %esi <== NOT EXECUTED 1091d5: 9d popf <== NOT EXECUTED * alignments are possible. 1091d6: c7 42 34 01 00 00 00 movl $0x1,0x34(%edx) <== NOT EXECUTED 1091dd: eb 34 jmp 109213 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1091df: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 1091e4: 40 inc %eax <== NOT EXECUTED 1091e5: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 1091ea: c7 41 44 01 00 00 00 movl $0x1,0x44(%ecx) <== NOT EXECUTED * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @param[in] alignment the required alignment 1091f1: 8d 41 14 lea 0x14(%ecx),%eax <== NOT EXECUTED 1091f4: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 1091f7: 89 7a 20 mov %edi,0x20(%edx) <== NOT EXECUTED */ 1091fa: 56 push %esi <== NOT EXECUTED 1091fb: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, 1091fc: 52 push %edx <== NOT EXECUTED 1091fd: 68 14 b5 10 00 push $0x10b514 <== NOT EXECUTED 109202: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 109205: 50 push %eax <== NOT EXECUTED 109206: e8 05 20 00 00 call 10b210 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED size_t size, 10920b: e8 b0 1b 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 109210: 83 c4 10 add $0x10,%esp <== NOT EXECUTED id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 109213: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109216: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 10921b: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10921e: e8 8c 00 00 00 call 1092af <_Semaphore_Translate_core_semaphore_return_code> <== NOT EXECUTED 109223: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } return RTEMS_INVALID_ID; } 109226: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109229: 5b pop %ebx <== NOT EXECUTED 10922a: 5e pop %esi <== NOT EXECUTED 10922b: 5f pop %edi <== NOT EXECUTED 10922c: c9 leave <== NOT EXECUTED 10922d: c3 ret <== NOT EXECUTED 00109230 : #endif rtems_status_code rtems_semaphore_release( rtems_id id ) { 109230: 55 push %ebp <== NOT EXECUTED 109231: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109233: 53 push %ebx <== NOT EXECUTED 109234: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 109237: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap 10923a: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10923d: 50 push %eax <== NOT EXECUTED 10923e: 53 push %ebx <== NOT EXECUTED 10923f: 68 48 c9 11 00 push $0x11c948 <== NOT EXECUTED 109244: e8 b7 13 00 00 call 10a600 <_Objects_Get> <== NOT EXECUTED 109249: 89 c2 mov %eax,%edx <== NOT EXECUTED Objects_Locations location; CORE_mutex_Status mutex_status; CORE_semaphore_Status semaphore_status; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 10924b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10924e: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 109253: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 109257: 75 40 jne 109299 <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 109259: f6 42 10 30 testb $0x30,0x10(%edx) <== NOT EXECUTED 10925d: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 109260: 74 1b je 10927d <== NOT EXECUTED mutex_status = _CORE_mutex_Surrender( 109262: 51 push %ecx <== NOT EXECUTED 109263: 6a 00 push $0x0 <== NOT EXECUTED 109265: 53 push %ebx <== NOT EXECUTED 109266: 50 push %eax <== NOT EXECUTED 109267: e8 8c 0a 00 00 call 109cf8 <_CORE_mutex_Surrender> <== NOT EXECUTED 10926c: 89 c3 mov %eax,%ebx <== NOT EXECUTED &the_semaphore->Core_control.mutex, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 10926e: e8 4d 1b 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED return _Semaphore_Translate_core_mutex_return_code( mutex_status ); 109273: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 109276: e8 25 00 00 00 call 1092a0 <_Semaphore_Translate_core_mutex_return_code> <== NOT EXECUTED 10927b: eb 19 jmp 109296 <== NOT EXECUTED } else { semaphore_status = _CORE_semaphore_Surrender( 10927d: 52 push %edx <== NOT EXECUTED 10927e: 6a 00 push $0x0 <== NOT EXECUTED 109280: 53 push %ebx <== NOT EXECUTED 109281: 50 push %eax <== NOT EXECUTED 109282: e8 b1 0b 00 00 call 109e38 <_CORE_semaphore_Surrender> <== NOT EXECUTED 109287: 89 c3 mov %eax,%ebx <== NOT EXECUTED &the_semaphore->Core_control.semaphore, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 109289: e8 32 1b 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED return 10928e: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 109291: e8 19 00 00 00 call 1092af <_Semaphore_Translate_core_semaphore_return_code> <== NOT EXECUTED 109296: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 109299: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10929c: c9 leave <== NOT EXECUTED 10929d: c3 ret <== NOT EXECUTED 00114dbc : */ void rtems_shutdown_executive( uint32_t result ) { 114dbc: 55 push %ebp <== NOT EXECUTED 114dbd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114dbf: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 114dc2: 83 3d a0 cb 11 00 04 cmpl $0x4,0x11cba0 <== NOT EXECUTED 114dc9: 74 1d je 114de8 <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 114dcb: c7 05 a0 cb 11 00 04 movl $0x4,0x11cba0 <== NOT EXECUTED 114dd2: 00 00 00 <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 114dd5: 50 push %eax <== NOT EXECUTED 114dd6: 50 push %eax <== NOT EXECUTED 114dd7: 68 e8 c9 11 00 push $0x11c9e8 <== NOT EXECUTED 114ddc: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 114ddf: 50 push %eax <== NOT EXECUTED 114de0: e8 0b 70 ff ff call 10bdf0 <_CPU_Context_switch> <== NOT EXECUTED 114de5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_SHUTDOWN ); _Thread_Stop_multitasking(); } } 114de8: c9 leave <== NOT EXECUTED 114de9: c3 ret <== NOT EXECUTED 00109ec4 : rtems_status_code rtems_signal_catch( rtems_asr_entry asr_handler, rtems_mode mode_set ) { 109ec4: 55 push %ebp <== NOT EXECUTED 109ec5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109ec7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109eca: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED RTEMS_API_Control *api; ASR_Information *asr; /* XXX normalize mode */ executing = _Thread_Executing; api = (RTEMS_API_Control*)executing->API_Extensions[ THREAD_API_RTEMS ]; 109ecd: a1 ac f5 11 00 mov 0x11f5ac,%eax <== NOT EXECUTED 109ed2: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109ed8: a1 ec f4 11 00 mov 0x11f4ec,%eax <== NOT EXECUTED 109edd: 40 inc %eax <== NOT EXECUTED 109ede: a3 ec f4 11 00 mov %eax,0x11f4ec <== NOT EXECUTED asr = &api->Signal; _Thread_Disable_dispatch(); /* cannot reschedule while */ /* the thread is inconsistent */ if ( !_ASR_Is_null_handler( asr_handler ) ) { 109ee3: 85 c9 test %ecx,%ecx <== NOT EXECUTED 109ee5: 74 0b je 109ef2 <== NOT EXECUTED asr->mode_set = mode_set; 109ee7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 109eea: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED asr->handler = asr_handler; 109eed: 89 4a 0c mov %ecx,0xc(%edx) <== NOT EXECUTED 109ef0: eb 27 jmp 109f19 <== NOT EXECUTED #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of 109ef2: c6 42 08 01 movb $0x1,0x8(%edx) <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of 109ef6: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) <== NOT EXECUTED * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 109efd: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED * 109f04: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 109f0b: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 109f12: c7 42 1c 00 00 00 00 movl $0x0,0x1c(%edx) <== NOT EXECUTED } else _ASR_Initialize( asr ); _Thread_Enable_dispatch(); 109f19: e8 ee 1d 00 00 call 10bd0c <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 109f1e: 31 c0 xor %eax,%eax <== NOT EXECUTED 109f20: c9 leave <== NOT EXECUTED 109f21: c3 ret <== NOT EXECUTED 001123a0 : rtems_status_code rtems_signal_send( Objects_Id id, rtems_signal_set signal_set ) { 1123a0: 55 push %ebp <== NOT EXECUTED 1123a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1123a3: 53 push %ebx <== NOT EXECUTED 1123a4: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 1123a7: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 1123aa: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 1123af: 85 db test %ebx,%ebx <== NOT EXECUTED 1123b1: 74 71 je 112424 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 1123b3: 50 push %eax <== NOT EXECUTED 1123b4: 50 push %eax <== NOT EXECUTED 1123b5: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1123b8: 50 push %eax <== NOT EXECUTED 1123b9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1123bc: e8 4b 33 00 00 call 11570c <_Thread_Get> <== NOT EXECUTED 1123c1: 89 c1 mov %eax,%ecx <== NOT EXECUTED switch ( location ) { 1123c3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1123c6: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1123cb: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 1123cf: 75 53 jne 112424 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 1123d1: 8b 91 f4 00 00 00 mov 0xf4(%ecx),%edx <== NOT EXECUTED asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 1123d7: 83 7a 0c 00 cmpl $0x0,0xc(%edx) <== NOT EXECUTED 1123db: 74 3d je 11241a <== NOT EXECUTED if ( asr->is_enabled ) { 1123dd: 80 7a 08 00 cmpb $0x0,0x8(%edx) <== NOT EXECUTED 1123e1: 74 26 je 112409 <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 1123e3: 9c pushf <== NOT EXECUTED 1123e4: fa cli <== NOT EXECUTED 1123e5: 58 pop %eax <== NOT EXECUTED ); 1123e6: 09 5a 14 or %ebx,0x14(%edx) <== NOT EXECUTED 1123e9: 50 push %eax <== NOT EXECUTED 1123ea: 9d popf <== NOT EXECUTED _ASR_Post_signals( signal_set, &asr->signals_posted ); the_thread->do_post_task_switch_extension = true; 1123eb: c6 41 75 01 movb $0x1,0x75(%ecx) <== NOT EXECUTED if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 1123ef: a1 7c 28 13 00 mov 0x13287c,%eax <== NOT EXECUTED 1123f4: 85 c0 test %eax,%eax <== NOT EXECUTED 1123f6: 74 19 je 112411 <== NOT EXECUTED 1123f8: 3b 0d a0 28 13 00 cmp 0x1328a0,%ecx <== NOT EXECUTED 1123fe: 75 11 jne 112411 <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 112400: c6 05 34 29 13 00 01 movb $0x1,0x132934 <== NOT EXECUTED 112407: eb 08 jmp 112411 <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 112409: 9c pushf <== NOT EXECUTED 11240a: fa cli <== NOT EXECUTED 11240b: 58 pop %eax <== NOT EXECUTED ); 11240c: 09 5a 18 or %ebx,0x18(%edx) <== NOT EXECUTED 11240f: 50 push %eax <== NOT EXECUTED 112410: 9d popf <== NOT EXECUTED } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 112411: e8 d6 32 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112416: 31 c0 xor %eax,%eax <== NOT EXECUTED 112418: eb 0a jmp 112424 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 11241a: e8 cd 32 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 11241f: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112424: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112427: c9 leave <== NOT EXECUTED 112428: c3 ret <== NOT EXECUTED 001092c0 : size_t stack_size, rtems_mode initial_modes, rtems_attribute attribute_set, Objects_Id *id ) { 1092c0: 55 push %ebp <== NOT EXECUTED 1092c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1092c3: 57 push %edi <== NOT EXECUTED 1092c4: 56 push %esi <== NOT EXECUTED 1092c5: 53 push %ebx <== NOT EXECUTED 1092c6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1092c9: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 1092cc: 8b 7d 18 mov 0x18(%ebp),%edi <== NOT EXECUTED Priority_Control core_priority; RTEMS_API_Control *api; ASR_Information *asr; if ( !id ) 1092cf: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 1092d4: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp) <== NOT EXECUTED 1092d8: 0f 84 08 01 00 00 je 1093e6 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 1092de: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 1092e3: 83 7d 08 00 cmpl $0x0,0x8(%ebp) <== NOT EXECUTED 1092e7: 0f 84 f9 00 00 00 je 1093e6 <== NOT EXECUTED /* * Validate the RTEMS API priority and convert it to the core priority range. */ if ( !_Attributes_Is_system_task( the_attribute_set ) ) { 1092ed: 66 85 ff test %di,%di <== NOT EXECUTED 1092f0: 78 24 js 109316 <== NOT EXECUTED bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ); 1092f2: 31 d2 xor %edx,%edx <== NOT EXECUTED 1092f4: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 1092f8: 74 0f je 109309 <== NOT EXECUTED 1092fa: 0f b6 05 84 86 11 00 movzbl 0x118684,%eax <== NOT EXECUTED 109301: 31 d2 xor %edx,%edx <== NOT EXECUTED 109303: 39 45 0c cmp %eax,0xc(%ebp) <== NOT EXECUTED 109306: 0f 96 c2 setbe %dl <== NOT EXECUTED if ( !_RTEMS_tasks_Priority_is_valid( initial_priority ) ) 109309: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED 10930e: 85 d2 test %edx,%edx <== NOT EXECUTED 109310: 0f 84 d0 00 00 00 je 1093e6 <== NOT EXECUTED */ /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 109316: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109319: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 10931f: e8 88 06 00 00 call 1099ac <_API_Mutex_Lock> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 109324: c7 04 24 88 c9 11 00 movl $0x11c988,(%esp) <== NOT EXECUTED 10932b: e8 8c 0e 00 00 call 10a1bc <_Objects_Allocate> <== NOT EXECUTED 109330: 89 c6 mov %eax,%esi <== NOT EXECUTED * the event of an error. */ the_thread = _RTEMS_tasks_Allocate(); if ( !the_thread ) { 109332: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109335: 85 c0 test %eax,%eax <== NOT EXECUTED 109337: 75 18 jne 109351 <== NOT EXECUTED _RTEMS_Unlock_allocator(); 109339: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10933c: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 109342: e8 ad 06 00 00 call 1099f4 <_API_Mutex_Unlock> <== NOT EXECUTED 109347: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10934c: e9 92 00 00 00 jmp 1093e3 <== NOT EXECUTED /* * Initialize the core thread for this task. */ status = _Thread_Initialize( 109351: 50 push %eax <== NOT EXECUTED 109352: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109355: 89 d8 mov %ebx,%eax <== NOT EXECUTED 109357: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10935a: 50 push %eax <== NOT EXECUTED 10935b: 6a 00 push $0x0 <== NOT EXECUTED 10935d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10935f: c1 e8 09 shr $0x9,%eax <== NOT EXECUTED 109362: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 109365: 50 push %eax <== NOT EXECUTED 109366: 89 d8 mov %ebx,%eax <== NOT EXECUTED 109368: c1 e8 08 shr $0x8,%eax <== NOT EXECUTED 10936b: 83 f0 01 xor $0x1,%eax <== NOT EXECUTED 10936e: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 109371: 50 push %eax <== NOT EXECUTED 109372: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109375: 83 e7 01 and $0x1,%edi <== NOT EXECUTED 109378: 57 push %edi <== NOT EXECUTED 109379: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10937c: 6a 00 push $0x0 <== NOT EXECUTED 10937e: 56 push %esi <== NOT EXECUTED 10937f: 68 88 c9 11 00 push $0x11c988 <== NOT EXECUTED 109384: e8 cf 1a 00 00 call 10ae58 <_Thread_Initialize> <== NOT EXECUTED NULL, /* no budget algorithm callout */ _Modes_Get_interrupt_level(initial_modes), (Objects_Name) name ); if ( !status ) { 109389: 83 c4 30 add $0x30,%esp <== NOT EXECUTED 10938c: 84 c0 test %al,%al <== NOT EXECUTED 10938e: 75 27 jne 1093b7 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 109390: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109393: ff 76 08 pushl 0x8(%esi) <== NOT EXECUTED 109396: e8 a5 11 00 00 call 10a540 <_Objects_Get_information_id> <== NOT EXECUTED 10939b: 5a pop %edx <== NOT EXECUTED 10939c: 59 pop %ecx <== NOT EXECUTED 10939d: 56 push %esi <== NOT EXECUTED 10939e: 50 push %eax <== NOT EXECUTED 10939f: e8 28 11 00 00 call 10a4cc <_Objects_Free> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( is_global ) _Objects_MP_Free_global_object( the_global_object ); #endif _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 1093a4: 58 pop %eax <== NOT EXECUTED 1093a5: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 1093ab: e8 44 06 00 00 call 1099f4 <_API_Mutex_Unlock> <== NOT EXECUTED 1093b0: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 1093b5: eb 2c jmp 1093e3 <== NOT EXECUTED } api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true; 1093b7: 8b 86 f4 00 00 00 mov 0xf4(%esi),%eax <== NOT EXECUTED 1093bd: c1 eb 0a shr $0xa,%ebx <== NOT EXECUTED 1093c0: 83 f3 01 xor $0x1,%ebx <== NOT EXECUTED 1093c3: 88 da mov %bl,%dl <== NOT EXECUTED 1093c5: 83 e2 01 and $0x1,%edx <== NOT EXECUTED 1093c8: 88 50 08 mov %dl,0x8(%eax) <== NOT EXECUTED *id = the_thread->Object.id; 1093cb: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 1093ce: 8b 55 1c mov 0x1c(%ebp),%edx <== NOT EXECUTED 1093d1: 89 02 mov %eax,(%edx) <== NOT EXECUTED ); } #endif _RTEMS_Unlock_allocator(); 1093d3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1093d6: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 1093dc: e8 13 06 00 00 call 1099f4 <_API_Mutex_Unlock> <== NOT EXECUTED 1093e1: 31 c0 xor %eax,%eax <== NOT EXECUTED 1093e3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 1093e6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1093e9: 5b pop %ebx <== NOT EXECUTED 1093ea: 5e pop %esi <== NOT EXECUTED 1093eb: 5f pop %edi <== NOT EXECUTED 1093ec: c9 leave <== NOT EXECUTED 1093ed: c3 ret <== NOT EXECUTED 001093f0 : */ rtems_status_code rtems_task_delete( Objects_Id id ) { 1093f0: 55 push %ebp <== NOT EXECUTED 1093f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1093f3: 53 push %ebx <== NOT EXECUTED 1093f4: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; _RTEMS_Lock_allocator(); 1093f7: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 1093fd: e8 aa 05 00 00 call 1099ac <_API_Mutex_Lock> <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); 109402: 5b pop %ebx <== NOT EXECUTED 109403: 58 pop %eax <== NOT EXECUTED 109404: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109407: 50 push %eax <== NOT EXECUTED 109408: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10940b: e8 d0 19 00 00 call 10ade0 <_Thread_Get> <== NOT EXECUTED 109410: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch ( location ) { 109412: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109415: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 109419: 75 3b jne 109456 <== NOT EXECUTED case OBJECTS_LOCAL: the_information = _Objects_Get_information_id( the_thread->Object.id ); 10941b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10941e: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 109421: e8 1a 11 00 00 call 10a540 <_Objects_Get_information_id> <== NOT EXECUTED 0 /* Not used */ ); } #endif _Thread_Close( the_information, the_thread ); 109426: 5a pop %edx <== NOT EXECUTED 109427: 59 pop %ecx <== NOT EXECUTED 109428: 53 push %ebx <== NOT EXECUTED 109429: 50 push %eax <== NOT EXECUTED 10942a: e8 99 16 00 00 call 10aac8 <_Thread_Close> <== NOT EXECUTED 10942f: 58 pop %eax <== NOT EXECUTED 109430: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 109433: e8 08 11 00 00 call 10a540 <_Objects_Get_information_id> <== NOT EXECUTED 109438: 5a pop %edx <== NOT EXECUTED 109439: 59 pop %ecx <== NOT EXECUTED 10943a: 53 push %ebx <== NOT EXECUTED 10943b: 50 push %eax <== NOT EXECUTED 10943c: e8 8b 10 00 00 call 10a4cc <_Objects_Free> <== NOT EXECUTED _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 109441: 58 pop %eax <== NOT EXECUTED 109442: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 109448: e8 a7 05 00 00 call 1099f4 <_API_Mutex_Unlock> <== NOT EXECUTED _Thread_Enable_dispatch(); 10944d: e8 6e 19 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 109452: 31 c0 xor %eax,%eax <== NOT EXECUTED 109454: eb 13 jmp 109469 <== NOT EXECUTED case OBJECTS_ERROR: break; } _RTEMS_Unlock_allocator(); 109456: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109459: ff 35 b8 ca 11 00 pushl 0x11cab8 <== NOT EXECUTED 10945f: e8 90 05 00 00 call 1099f4 <_API_Mutex_Unlock> <== NOT EXECUTED 109464: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 109469: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_INVALID_ID; } 10946c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10946f: c9 leave <== NOT EXECUTED 109470: c3 ret <== NOT EXECUTED 0010aa08 : rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) { 10aa08: 55 push %ebp <== NOT EXECUTED 10aa09: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa0b: 56 push %esi <== NOT EXECUTED 10aa0c: 53 push %ebx <== NOT EXECUTED 10aa0d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10aa10: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10aa13: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10aa16: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10aa19: a1 ac 07 12 00 mov 0x1207ac,%eax <== NOT EXECUTED 10aa1e: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10aa21: ba 16 00 00 00 mov $0x16,%edx <== NOT EXECUTED 10aa26: 80 78 04 00 cmpb $0x0,0x4(%eax) <== NOT EXECUTED 10aa2a: 74 61 je 10aa8d <== NOT EXECUTED return RTEMS_NOT_CONFIGURED; if ( !note ) 10aa2c: ba 09 00 00 00 mov $0x9,%edx <== NOT EXECUTED 10aa31: 85 f6 test %esi,%esi <== NOT EXECUTED 10aa33: 74 58 je 10aa8d <== NOT EXECUTED /* * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) 10aa35: ba 0a 00 00 00 mov $0xa,%edx <== NOT EXECUTED 10aa3a: 83 fb 0f cmp $0xf,%ebx <== NOT EXECUTED 10aa3d: 77 4e ja 10aa8d <== NOT EXECUTED /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10aa3f: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10aa41: 74 0a je 10aa4d <== NOT EXECUTED 10aa43: a1 d4 07 12 00 mov 0x1207d4,%eax <== NOT EXECUTED 10aa48: 3b 48 08 cmp 0x8(%eax),%ecx <== NOT EXECUTED 10aa4b: 75 13 jne 10aa60 <== NOT EXECUTED _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10aa4d: a1 d4 07 12 00 mov 0x1207d4,%eax <== NOT EXECUTED 10aa52: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10aa58: 8b 44 98 20 mov 0x20(%eax,%ebx,4),%eax <== NOT EXECUTED 10aa5c: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10aa5e: eb 2b jmp 10aa8b <== NOT EXECUTED return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10aa60: 50 push %eax <== NOT EXECUTED 10aa61: 50 push %eax <== NOT EXECUTED 10aa62: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10aa65: 50 push %eax <== NOT EXECUTED 10aa66: 51 push %ecx <== NOT EXECUTED 10aa67: e8 38 1c 00 00 call 10c6a4 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10aa6c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aa6f: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED 10aa74: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 10aa78: 75 13 jne 10aa8d <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10aa7a: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10aa80: 8b 44 98 20 mov 0x20(%eax,%ebx,4),%eax <== NOT EXECUTED 10aa84: 89 06 mov %eax,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10aa86: e8 f9 1b 00 00 call 10c684 <_Thread_Enable_dispatch> <== NOT EXECUTED 10aa8b: 31 d2 xor %edx,%edx <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10aa8d: 89 d0 mov %edx,%eax <== NOT EXECUTED 10aa8f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10aa92: 5b pop %ebx <== NOT EXECUTED 10aa93: 5e pop %esi <== NOT EXECUTED 10aa94: c9 leave <== NOT EXECUTED 10aa95: c3 ret <== NOT EXECUTED 00109474 : rtems_status_code rtems_task_ident( rtems_name name, uint32_t node, Objects_Id *id ) { 109474: 55 push %ebp <== NOT EXECUTED 109475: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109477: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10947a: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10947d: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; if ( !id ) 109480: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 109485: 85 d2 test %edx,%edx <== NOT EXECUTED 109487: 74 2b je 1094b4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( name == OBJECTS_ID_OF_SELF ) { 109489: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10948b: 75 0e jne 10949b <== NOT EXECUTED *id = _Thread_Executing->Object.id; 10948d: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 109492: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 109495: 89 02 mov %eax,(%edx) <== NOT EXECUTED 109497: 31 c0 xor %eax,%eax <== NOT EXECUTED 109499: eb 19 jmp 1094b4 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id ); 10949b: 52 push %edx <== NOT EXECUTED 10949c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10949f: 51 push %ecx <== NOT EXECUTED 1094a0: 68 88 c9 11 00 push $0x11c988 <== NOT EXECUTED 1094a5: e8 9e 12 00 00 call 10a748 <_Objects_Name_to_id_u32> <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; 1094aa: 8b 04 85 34 68 11 00 mov 0x116834(,%eax,4),%eax <== NOT EXECUTED 1094b1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1094b4: c9 leave <== NOT EXECUTED 1094b5: c3 ret <== NOT EXECUTED 001099c0 : */ rtems_status_code rtems_task_is_suspended( Objects_Id id ) { 1099c0: 55 push %ebp <== NOT EXECUTED 1099c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099c3: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 1099c6: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 1099c9: 50 push %eax <== NOT EXECUTED 1099ca: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1099cd: e8 a6 19 00 00 call 10b378 <_Thread_Get> <== NOT EXECUTED 1099d2: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 1099d4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1099d7: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1099dc: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 1099e0: 75 19 jne 1099fb <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 1099e2: f6 42 10 02 testb $0x2,0x10(%edx) <== NOT EXECUTED 1099e6: 75 09 jne 1099f1 <== NOT EXECUTED _Thread_Enable_dispatch(); 1099e8: e8 6b 19 00 00 call 10b358 <_Thread_Enable_dispatch> <== NOT EXECUTED 1099ed: 31 c0 xor %eax,%eax <== NOT EXECUTED 1099ef: eb 0a jmp 1099fb <== NOT EXECUTED return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 1099f1: e8 62 19 00 00 call 10b358 <_Thread_Enable_dispatch> <== NOT EXECUTED 1099f6: b8 0f 00 00 00 mov $0xf,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1099fb: c9 leave <== NOT EXECUTED 1099fc: c3 ret <== NOT EXECUTED 0010e280 : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 10e280: 55 push %ebp <== NOT EXECUTED 10e281: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e283: 57 push %edi <== NOT EXECUTED 10e284: 56 push %esi <== NOT EXECUTED 10e285: 53 push %ebx <== NOT EXECUTED 10e286: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e289: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED ASR_Information *asr; bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) 10e28c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10e291: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 10e295: 0f 84 04 01 00 00 je 10e39f <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 10e29b: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 10e2a0: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10e2a3: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx <== NOT EXECUTED 10e2a9: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 10e2ac: 80 78 76 01 cmpb $0x1,0x76(%eax) <== NOT EXECUTED 10e2b0: 19 f6 sbb %esi,%esi <== NOT EXECUTED 10e2b2: 81 e6 00 01 00 00 and $0x100,%esi <== NOT EXECUTED if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 10e2b8: 83 78 7c 00 cmpl $0x0,0x7c(%eax) <== NOT EXECUTED 10e2bc: 74 06 je 10e2c4 <== NOT EXECUTED old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 10e2be: 81 ce 00 02 00 00 or $0x200,%esi <== NOT EXECUTED old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 10e2c4: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 10e2c7: 80 7b 08 01 cmpb $0x1,0x8(%ebx) <== NOT EXECUTED 10e2cb: 19 db sbb %ebx,%ebx <== NOT EXECUTED 10e2cd: 81 e3 00 04 00 00 and $0x400,%ebx <== NOT EXECUTED old_mode |= _ISR_Get_level(); 10e2d3: e8 f3 dc ff ff call 10bfcb <_CPU_ISR_Get_level> <== NOT EXECUTED 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; 10e2d8: 09 c3 or %eax,%ebx <== NOT EXECUTED old_mode |= _ISR_Get_level(); *previous_mode_set = old_mode; 10e2da: 09 f3 or %esi,%ebx <== NOT EXECUTED 10e2dc: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10e2df: 89 18 mov %ebx,(%eax) <== NOT EXECUTED /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 10e2e1: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) <== NOT EXECUTED 10e2e8: 74 11 je 10e2fb <== NOT EXECUTED executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE; 10e2ea: 89 f8 mov %edi,%eax <== NOT EXECUTED 10e2ec: c1 e8 08 shr $0x8,%eax <== NOT EXECUTED 10e2ef: 83 f0 01 xor $0x1,%eax <== NOT EXECUTED 10e2f2: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10e2f5: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10e2f8: 88 42 76 mov %al,0x76(%edx) <== NOT EXECUTED if ( mask & RTEMS_TIMESLICE_MASK ) { 10e2fb: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) <== NOT EXECUTED 10e302: 74 26 je 10e32a <== NOT EXECUTED if ( _Modes_Is_timeslice(mode_set) ) { 10e304: f7 c7 00 02 00 00 test $0x200,%edi <== NOT EXECUTED 10e30a: 74 14 je 10e320 <== NOT EXECUTED executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 10e30c: 8b 5d ec mov -0x14(%ebp),%ebx <== NOT EXECUTED 10e30f: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx) <== NOT EXECUTED executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10e316: a1 cc c9 11 00 mov 0x11c9cc,%eax <== NOT EXECUTED 10e31b: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10e31e: eb 0a jmp 10e32a <== NOT EXECUTED } else executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 10e320: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10e323: c7 40 7c 00 00 00 00 movl $0x0,0x7c(%eax) <== NOT EXECUTED /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 10e32a: f6 45 0c 01 testb $0x1,0xc(%ebp) <== NOT EXECUTED 10e32e: 74 0c je 10e33c <== NOT EXECUTED * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @param[in] alignment the required alignment 10e330: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED 10e336: 74 03 je 10e33b <== NOT EXECUTED 10e338: fa cli <== NOT EXECUTED 10e339: eb 01 jmp 10e33c <== NOT EXECUTED 10e33b: fb sti <== NOT EXECUTED */ is_asr_enabled = FALSE; needs_asr_dispatching = FALSE; if ( mask & RTEMS_ASR_MASK ) { 10e33c: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) <== NOT EXECUTED 10e343: 74 3b je 10e380 <== NOT EXECUTED 10e345: c1 ef 0a shr $0xa,%edi <== NOT EXECUTED 10e348: 83 f7 01 xor $0x1,%edi <== NOT EXECUTED 10e34b: 89 f8 mov %edi,%eax <== NOT EXECUTED 10e34d: 83 e0 01 and $0x1,%eax <== NOT EXECUTED is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true; if ( is_asr_enabled != asr->is_enabled ) { 10e350: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10e353: 3a 42 08 cmp 0x8(%edx),%al <== NOT EXECUTED 10e356: 74 28 je 10e380 <== NOT EXECUTED asr->is_enabled = is_asr_enabled; 10e358: 88 42 08 mov %al,0x8(%edx) <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10e35b: 9c pushf <== NOT EXECUTED 10e35c: fa cli <== NOT EXECUTED 10e35d: 59 pop %ecx <== NOT EXECUTED /** 10e35e: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 10e361: 8b 53 18 mov 0x18(%ebx),%edx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 10e364: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10e367: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED * begin at @a starting_address. 10e36a: 89 53 14 mov %edx,0x14(%ebx) <== NOT EXECUTED * 10e36d: 51 push %ecx <== NOT EXECUTED 10e36e: 9d popf <== NOT EXECUTED _ASR_Swap_signals( asr ); if ( _ASR_Are_signals_pending( asr ) ) { 10e36f: 83 7b 14 00 cmpl $0x0,0x14(%ebx) <== NOT EXECUTED 10e373: 74 0b je 10e380 <== NOT EXECUTED needs_asr_dispatching = true; executing->do_post_task_switch_extension = true; 10e375: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10e378: c6 40 75 01 movb $0x1,0x75(%eax) <== NOT EXECUTED 10e37c: b3 01 mov $0x1,%bl <== NOT EXECUTED 10e37e: eb 02 jmp 10e382 <== NOT EXECUTED 10e380: 31 db xor %ebx,%ebx <== NOT EXECUTED } } } if ( _System_state_Is_up(_System_state_Current) ) 10e382: 83 3d a0 cb 11 00 03 cmpl $0x3,0x11cba0 <== NOT EXECUTED 10e389: 75 12 jne 10e39d <== NOT EXECUTED if ( _Thread_Evaluate_mode() || needs_asr_dispatching ) 10e38b: e8 58 01 00 00 call 10e4e8 <_Thread_Evaluate_mode> <== NOT EXECUTED 10e390: 84 c0 test %al,%al <== NOT EXECUTED 10e392: 75 04 jne 10e398 <== NOT EXECUTED 10e394: 84 db test %bl,%bl <== NOT EXECUTED 10e396: 74 05 je 10e39d <== NOT EXECUTED _Thread_Dispatch(); 10e398: e8 df c8 ff ff call 10ac7c <_Thread_Dispatch> <== NOT EXECUTED 10e39d: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10e39f: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10e3a2: 5b pop %ebx <== NOT EXECUTED 10e3a3: 5e pop %esi <== NOT EXECUTED 10e3a4: 5f pop %edi <== NOT EXECUTED 10e3a5: c9 leave <== NOT EXECUTED 10e3a6: c3 ret <== NOT EXECUTED 00109dd0 : rtems_status_code rtems_task_restart( Objects_Id id, uint32_t argument ) { 109dd0: 55 push %ebp <== NOT EXECUTED 109dd1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109dd3: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 109dd6: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 109dd9: 50 push %eax <== NOT EXECUTED 109dda: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109ddd: e8 9a 19 00 00 call 10b77c <_Thread_Get> <== NOT EXECUTED 109de2: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 109de4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109de7: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 109dec: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 109df0: 75 26 jne 109e18 <== NOT EXECUTED case OBJECTS_LOCAL: if ( _Thread_Restart( the_thread, NULL, argument ) ) { 109df2: 50 push %eax <== NOT EXECUTED 109df3: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109df6: 6a 00 push $0x0 <== NOT EXECUTED 109df8: 52 push %edx <== NOT EXECUTED 109df9: e8 e6 20 00 00 call 10bee4 <_Thread_Restart> <== NOT EXECUTED 109dfe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109e01: 84 c0 test %al,%al <== NOT EXECUTED 109e03: 74 09 je 109e0e <== NOT EXECUTED _Thread_Enable_dispatch(); 109e05: e8 52 19 00 00 call 10b75c <_Thread_Enable_dispatch> <== NOT EXECUTED 109e0a: 31 c0 xor %eax,%eax <== NOT EXECUTED 109e0c: eb 0a jmp 109e18 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 109e0e: e8 49 19 00 00 call 10b75c <_Thread_Enable_dispatch> <== NOT EXECUTED 109e13: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 109e18: c9 leave <== NOT EXECUTED 109e19: c3 ret <== NOT EXECUTED 0010a584 : */ rtems_status_code rtems_task_resume( Objects_Id id ) { 10a584: 55 push %ebp <== NOT EXECUTED 10a585: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a587: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10a58a: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10a58d: 50 push %eax <== NOT EXECUTED 10a58e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a591: e8 f6 1b 00 00 call 10c18c <_Thread_Get> <== NOT EXECUTED 10a596: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 10a598: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a59b: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10a5a0: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 10a5a4: 75 26 jne 10a5cc <== NOT EXECUTED case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { 10a5a6: f6 42 10 02 testb $0x2,0x10(%edx) <== NOT EXECUTED 10a5aa: 74 16 je 10a5c2 <== NOT EXECUTED _Thread_Resume( the_thread, TRUE ); 10a5ac: 50 push %eax <== NOT EXECUTED 10a5ad: 50 push %eax <== NOT EXECUTED 10a5ae: 6a 01 push $0x1 <== NOT EXECUTED 10a5b0: 52 push %edx <== NOT EXECUTED 10a5b1: e8 3e 23 00 00 call 10c8f4 <_Thread_Resume> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a5b6: e8 85 1b 00 00 call 10c140 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a5bb: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a5bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a5c0: eb 0a jmp 10a5cc <== NOT EXECUTED return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10a5c2: e8 79 1b 00 00 call 10c140 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a5c7: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a5cc: c9 leave <== NOT EXECUTED 10a5cd: c3 ret <== NOT EXECUTED 00121278 : #include #include rtems_id rtems_task_self(void) { 121278: 55 push %ebp <== NOT EXECUTED 121279: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12127b: a1 b4 9c 15 00 mov 0x159cb4,%eax <== NOT EXECUTED 121280: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED return _Thread_Executing->Object.id; } 121283: c9 leave <== NOT EXECUTED 121284: c3 ret <== NOT EXECUTED 0010ab6c : rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) { 10ab6c: 55 push %ebp <== NOT EXECUTED 10ab6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ab6f: 56 push %esi <== NOT EXECUTED 10ab70: 53 push %ebx <== NOT EXECUTED 10ab71: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ab74: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ab77: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10ab7a: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10ab7d: a1 ac 07 12 00 mov 0x1207ac,%eax <== NOT EXECUTED 10ab82: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10ab85: ba 16 00 00 00 mov $0x16,%edx <== NOT EXECUTED 10ab8a: 80 78 04 00 cmpb $0x0,0x4(%eax) <== NOT EXECUTED 10ab8e: 74 54 je 10abe4 <== NOT EXECUTED /* * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) 10ab90: ba 0a 00 00 00 mov $0xa,%edx <== NOT EXECUTED 10ab95: 83 fb 0f cmp $0xf,%ebx <== NOT EXECUTED 10ab98: 77 4a ja 10abe4 <== NOT EXECUTED /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10ab9a: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ab9c: 74 0a je 10aba8 <== NOT EXECUTED 10ab9e: a1 d4 07 12 00 mov 0x1207d4,%eax <== NOT EXECUTED 10aba3: 3b 48 08 cmp 0x8(%eax),%ecx <== NOT EXECUTED 10aba6: 75 11 jne 10abb9 <== NOT EXECUTED _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10aba8: a1 d4 07 12 00 mov 0x1207d4,%eax <== NOT EXECUTED 10abad: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10abb3: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4) <== NOT EXECUTED 10abb7: eb 29 jmp 10abe2 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10abb9: 50 push %eax <== NOT EXECUTED 10abba: 50 push %eax <== NOT EXECUTED 10abbb: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10abbe: 50 push %eax <== NOT EXECUTED 10abbf: 51 push %ecx <== NOT EXECUTED 10abc0: e8 df 1a 00 00 call 10c6a4 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10abc5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10abc8: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED 10abcd: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 10abd1: 75 11 jne 10abe4 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10abd3: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10abd9: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4) <== NOT EXECUTED _Thread_Enable_dispatch(); 10abdd: e8 a2 1a 00 00 call 10c684 <_Thread_Enable_dispatch> <== NOT EXECUTED 10abe2: 31 d2 xor %edx,%edx <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10abe4: 89 d0 mov %edx,%eax <== NOT EXECUTED 10abe6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10abe9: 5b pop %ebx <== NOT EXECUTED 10abea: 5e pop %esi <== NOT EXECUTED 10abeb: c9 leave <== NOT EXECUTED 10abec: c3 ret <== NOT EXECUTED 0010ca18 : rtems_status_code rtems_task_set_priority( Objects_Id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10ca18: 55 push %ebp <== NOT EXECUTED 10ca19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca1b: 56 push %esi <== NOT EXECUTED 10ca1c: 53 push %ebx <== NOT EXECUTED 10ca1d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ca20: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10ca23: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10ca26: 85 db test %ebx,%ebx <== NOT EXECUTED 10ca28: 74 10 je 10ca3a <== NOT EXECUTED 10ca2a: 0f b6 05 24 34 12 00 movzbl 0x123424,%eax <== NOT EXECUTED 10ca31: ba 13 00 00 00 mov $0x13,%edx <== NOT EXECUTED 10ca36: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10ca38: 77 52 ja 10ca8c <== NOT EXECUTED !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 10ca3a: ba 09 00 00 00 mov $0x9,%edx <== NOT EXECUTED 10ca3f: 85 f6 test %esi,%esi <== NOT EXECUTED 10ca41: 74 49 je 10ca8c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10ca43: 52 push %edx <== NOT EXECUTED 10ca44: 52 push %edx <== NOT EXECUTED 10ca45: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10ca48: 50 push %eax <== NOT EXECUTED 10ca49: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ca4c: e8 37 1a 00 00 call 10e488 <_Thread_Get> <== NOT EXECUTED 10ca51: 89 c1 mov %eax,%ecx <== NOT EXECUTED switch ( location ) { 10ca53: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ca56: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED 10ca5b: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 10ca5f: 75 2b jne 10ca8c <== NOT EXECUTED case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10ca61: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10ca64: 89 06 mov %eax,(%esi) <== NOT EXECUTED if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10ca66: 85 db test %ebx,%ebx <== NOT EXECUTED 10ca68: 74 1b je 10ca85 <== NOT EXECUTED the_thread->real_priority = new_priority; 10ca6a: 89 59 18 mov %ebx,0x18(%ecx) <== NOT EXECUTED if ( the_thread->resource_count == 0 || 10ca6d: 83 79 1c 00 cmpl $0x0,0x1c(%ecx) <== NOT EXECUTED 10ca71: 74 05 je 10ca78 <== NOT EXECUTED 10ca73: 39 59 14 cmp %ebx,0x14(%ecx) <== NOT EXECUTED 10ca76: 76 0d jbe 10ca85 <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, FALSE ); 10ca78: 50 push %eax <== NOT EXECUTED 10ca79: 6a 00 push $0x0 <== NOT EXECUTED 10ca7b: 53 push %ebx <== NOT EXECUTED 10ca7c: 51 push %ecx <== NOT EXECUTED 10ca7d: e8 1a 15 00 00 call 10df9c <_Thread_Change_priority> <== NOT EXECUTED 10ca82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _Thread_Enable_dispatch(); 10ca85: e8 b2 19 00 00 call 10e43c <_Thread_Enable_dispatch> <== NOT EXECUTED 10ca8a: 31 d2 xor %edx,%edx <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ca8c: 89 d0 mov %edx,%eax <== NOT EXECUTED 10ca8e: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ca91: 5b pop %ebx <== NOT EXECUTED 10ca92: 5e pop %esi <== NOT EXECUTED 10ca93: c9 leave <== NOT EXECUTED 10ca94: c3 ret <== NOT EXECUTED 00109530 : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 109530: 55 push %ebp <== NOT EXECUTED 109531: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109533: 53 push %ebx <== NOT EXECUTED 109534: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 109537: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 10953a: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10953f: 85 db test %ebx,%ebx <== NOT EXECUTED 109541: 74 49 je 10958c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 109543: 50 push %eax <== NOT EXECUTED 109544: 50 push %eax <== NOT EXECUTED 109545: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109548: 50 push %eax <== NOT EXECUTED 109549: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10954c: e8 8f 18 00 00 call 10ade0 <_Thread_Get> <== NOT EXECUTED 109551: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 109553: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109556: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10955b: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 10955f: 75 2b jne 10958c <== NOT EXECUTED case OBJECTS_LOCAL: if ( _Thread_Start( 109561: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109564: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 109567: 6a 00 push $0x0 <== NOT EXECUTED 109569: 53 push %ebx <== NOT EXECUTED 10956a: 6a 00 push $0x0 <== NOT EXECUTED 10956c: 52 push %edx <== NOT EXECUTED 10956d: e8 56 22 00 00 call 10b7c8 <_Thread_Start> <== NOT EXECUTED 109572: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109575: 84 c0 test %al,%al <== NOT EXECUTED 109577: 74 09 je 109582 <== NOT EXECUTED the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); 109579: e8 42 18 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10957e: 31 c0 xor %eax,%eax <== NOT EXECUTED 109580: eb 0a jmp 10958c <== NOT EXECUTED return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 109582: e8 39 18 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED 109587: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10958c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10958f: c9 leave <== NOT EXECUTED 109590: c3 ret <== NOT EXECUTED 0010a634 : */ rtems_status_code rtems_task_suspend( Objects_Id id ) { 10a634: 55 push %ebp <== NOT EXECUTED 10a635: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a637: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10a63a: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10a63d: 50 push %eax <== NOT EXECUTED 10a63e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a641: e8 46 1b 00 00 call 10c18c <_Thread_Get> <== NOT EXECUTED 10a646: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 10a648: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a64b: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10a650: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 10a654: 75 25 jne 10a67b <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 10a656: f6 42 10 02 testb $0x2,0x10(%edx) <== NOT EXECUTED 10a65a: 75 15 jne 10a671 <== NOT EXECUTED _Thread_Suspend( the_thread ); 10a65c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a65f: 52 push %edx <== NOT EXECUTED 10a660: e8 0f 26 00 00 call 10cc74 <_Thread_Suspend> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a665: e8 d6 1a 00 00 call 10c140 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a66a: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a66c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a66f: eb 0a jmp 10a67b <== NOT EXECUTED return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10a671: e8 ca 1a 00 00 call 10c140 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a676: b8 0f 00 00 00 mov $0xf,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a67b: c9 leave <== NOT EXECUTED 10a67c: c3 ret <== NOT EXECUTED 00121470 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 121470: 55 push %ebp <== NOT EXECUTED 121471: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121473: 57 push %edi <== NOT EXECUTED 121474: 56 push %esi <== NOT EXECUTED 121475: 53 push %ebx <== NOT EXECUTED 121476: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 121479: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 12147c: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 12147f: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 121484: 85 f6 test %esi,%esi <== NOT EXECUTED 121486: 74 75 je 1214fd <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 121488: 50 push %eax <== NOT EXECUTED 121489: 50 push %eax <== NOT EXECUTED 12148a: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 12148d: 50 push %eax <== NOT EXECUTED 12148e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 121491: e8 ca e4 fe ff call 10f960 <_Thread_Get> <== NOT EXECUTED 121496: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch (location) { 121498: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12149b: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1214a0: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 1214a4: 75 57 jne 1214fd <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 1214a6: 8b 83 04 01 00 00 mov 0x104(%ebx),%eax <== NOT EXECUTED 1214ac: eb 0c jmp 1214ba <== NOT EXECUTED while (tvp) { if (tvp->ptr == ptr) { 1214ae: 39 70 04 cmp %esi,0x4(%eax) <== NOT EXECUTED 1214b1: 75 05 jne 1214b8 <== NOT EXECUTED tvp->dtor = dtor; 1214b3: 89 78 10 mov %edi,0x10(%eax) <== NOT EXECUTED 1214b6: eb 3e jmp 1214f6 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 1214b8: 8b 00 mov (%eax),%eax <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 1214ba: 85 c0 test %eax,%eax <== NOT EXECUTED 1214bc: 75 f0 jne 1214ae <== NOT EXECUTED } /* * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) 1214be: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1214c1: 6a 14 push $0x14 <== NOT EXECUTED 1214c3: e8 15 f4 fe ff call 1108dd <_Workspace_Allocate> <== NOT EXECUTED 1214c8: 89 c2 mov %eax,%edx <== NOT EXECUTED _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 1214ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1214cd: 85 c0 test %eax,%eax <== NOT EXECUTED 1214cf: 75 0c jne 1214dd <== NOT EXECUTED _Thread_Enable_dispatch(); 1214d1: e8 6a e4 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 1214d6: b8 1a 00 00 00 mov $0x1a,%eax <== NOT EXECUTED 1214db: eb 20 jmp 1214fd <== NOT EXECUTED return RTEMS_NO_MEMORY; } new->gval = *ptr; 1214dd: 8b 06 mov (%esi),%eax <== NOT EXECUTED 1214df: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED new->ptr = ptr; 1214e2: 89 72 04 mov %esi,0x4(%edx) <== NOT EXECUTED new->dtor = dtor; 1214e5: 89 7a 10 mov %edi,0x10(%edx) <== NOT EXECUTED new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 1214e8: 8b 83 04 01 00 00 mov 0x104(%ebx),%eax <== NOT EXECUTED 1214ee: 89 02 mov %eax,(%edx) <== NOT EXECUTED the_thread->task_variables = new; 1214f0: 89 93 04 01 00 00 mov %edx,0x104(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 1214f6: e8 45 e4 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 1214fb: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1214fd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 121500: 5b pop %ebx <== NOT EXECUTED 121501: 5e pop %esi <== NOT EXECUTED 121502: 5f pop %edi <== NOT EXECUTED 121503: c9 leave <== NOT EXECUTED 121504: c3 ret <== NOT EXECUTED 00121508 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 121508: 55 push %ebp <== NOT EXECUTED 121509: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12150b: 56 push %esi <== NOT EXECUTED 12150c: 53 push %ebx <== NOT EXECUTED 12150d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 121510: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 121513: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 121518: 85 f6 test %esi,%esi <== NOT EXECUTED 12151a: 74 64 je 121580 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); 12151c: 52 push %edx <== NOT EXECUTED 12151d: 52 push %edx <== NOT EXECUTED 12151e: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 121521: 50 push %eax <== NOT EXECUTED 121522: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 121525: e8 36 e4 fe ff call 10f960 <_Thread_Get> <== NOT EXECUTED 12152a: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch (location) { 12152c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12152f: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 121534: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 121538: 75 46 jne 121580 <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; 12153a: 8b 93 04 01 00 00 mov 0x104(%ebx),%edx <== NOT EXECUTED 121540: 31 c0 xor %eax,%eax <== NOT EXECUTED 121542: eb 2e jmp 121572 <== NOT EXECUTED while (tvp) { if (tvp->ptr == ptr) { 121544: 39 72 04 cmp %esi,0x4(%edx) <== NOT EXECUTED 121547: 75 25 jne 12156e <== NOT EXECUTED if (prev) 121549: 85 c0 test %eax,%eax <== NOT EXECUTED 12154b: 8b 0a mov (%edx),%ecx <== NOT EXECUTED 12154d: 74 04 je 121553 <== NOT EXECUTED prev->next = tvp->next; 12154f: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 121551: eb 06 jmp 121559 <== NOT EXECUTED else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 121553: 89 8b 04 01 00 00 mov %ecx,0x104(%ebx) <== NOT EXECUTED _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); 121559: 50 push %eax <== NOT EXECUTED 12155a: 50 push %eax <== NOT EXECUTED 12155b: 52 push %edx <== NOT EXECUTED 12155c: 53 push %ebx <== NOT EXECUTED 12155d: e8 8e 00 00 00 call 1215f0 <_RTEMS_Tasks_Invoke_task_variable_dtor> <== NOT EXECUTED _Thread_Enable_dispatch(); 121562: e8 d9 e3 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 121567: 31 c0 xor %eax,%eax <== NOT EXECUTED 121569: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12156c: eb 12 jmp 121580 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 12156e: 89 d0 mov %edx,%eax <== NOT EXECUTED 121570: 8b 12 mov (%edx),%edx <== NOT EXECUTED the_thread = _Thread_Get (tid, &location); switch (location) { case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 121572: 85 d2 test %edx,%edx <== NOT EXECUTED 121574: 75 ce jne 121544 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 121576: e8 c5 e3 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 12157b: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 121580: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 121583: 5b pop %ebx <== NOT EXECUTED 121584: 5e pop %esi <== NOT EXECUTED 121585: c9 leave <== NOT EXECUTED 121586: c3 ret <== NOT EXECUTED 00121588 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 121588: 55 push %ebp <== NOT EXECUTED 121589: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12158b: 56 push %esi <== NOT EXECUTED 12158c: 53 push %ebx <== NOT EXECUTED 12158d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 121590: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 121593: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 121596: 85 db test %ebx,%ebx <== NOT EXECUTED 121598: 74 48 je 1215e2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !result ) 12159a: 85 f6 test %esi,%esi <== NOT EXECUTED 12159c: 74 44 je 1215e2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 12159e: 50 push %eax <== NOT EXECUTED 12159f: 50 push %eax <== NOT EXECUTED 1215a0: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1215a3: 50 push %eax <== NOT EXECUTED 1215a4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1215a7: e8 b4 e3 fe ff call 10f960 <_Thread_Get> <== NOT EXECUTED 1215ac: 89 c2 mov %eax,%edx <== NOT EXECUTED switch (location) { 1215ae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1215b1: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 1215b6: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) <== NOT EXECUTED 1215ba: 75 2b jne 1215e7 <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 1215bc: 8b 82 04 01 00 00 mov 0x104(%edx),%eax <== NOT EXECUTED 1215c2: eb 15 jmp 1215d9 <== NOT EXECUTED while (tvp) { if (tvp->ptr == ptr) { 1215c4: 39 58 04 cmp %ebx,0x4(%eax) <== NOT EXECUTED 1215c7: 75 0e jne 1215d7 <== NOT EXECUTED /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 1215c9: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 1215cc: 89 06 mov %eax,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 1215ce: e8 6d e3 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED 1215d3: 31 c0 xor %eax,%eax <== NOT EXECUTED 1215d5: eb 10 jmp 1215e7 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 1215d7: 8b 00 mov (%eax),%eax <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 1215d9: 85 c0 test %eax,%eax <== NOT EXECUTED 1215db: 75 e7 jne 1215c4 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 1215dd: e8 5e e3 fe ff call 10f940 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 1215e2: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1215e7: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1215ea: 5b pop %ebx <== NOT EXECUTED 1215eb: 5e pop %esi <== NOT EXECUTED 1215ec: c9 leave <== NOT EXECUTED 1215ed: c3 ret <== NOT EXECUTED 00109594 : */ rtems_status_code rtems_task_wake_after( rtems_interval ticks ) { 109594: 55 push %ebp <== NOT EXECUTED 109595: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109597: 53 push %ebx <== NOT EXECUTED 109598: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10959b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10959e: a1 00 ca 11 00 mov 0x11ca00,%eax <== NOT EXECUTED 1095a3: 40 inc %eax <== NOT EXECUTED 1095a4: a3 00 ca 11 00 mov %eax,0x11ca00 <== NOT EXECUTED _Thread_Disable_dispatch(); if ( ticks == 0 ) { 1095a9: 85 db test %ebx,%ebx <== NOT EXECUTED 1095ab: 75 07 jne 1095b4 <== NOT EXECUTED _Thread_Yield_processor(); 1095ad: e8 d6 22 00 00 call 10b888 <_Thread_Yield_processor> <== NOT EXECUTED 1095b2: eb 45 jmp 1095f9 <== NOT EXECUTED } else { _Thread_Set_state( _Thread_Executing, STATES_DELAYING ); 1095b4: 50 push %eax <== NOT EXECUTED 1095b5: 50 push %eax <== NOT EXECUTED 1095b6: 6a 08 push $0x8 <== NOT EXECUTED 1095b8: ff 35 c0 ca 11 00 pushl 0x11cac0 <== NOT EXECUTED 1095be: e8 ed 1f 00 00 call 10b5b0 <_Thread_Set_state> <== NOT EXECUTED _Watchdog_Initialize( 1095c3: a1 c0 ca 11 00 mov 0x11cac0,%eax <== NOT EXECUTED 1095c8: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 1095cb: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 1095d2: c7 40 64 44 ac 10 00 movl $0x10ac44,0x64(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 1095d9: 89 50 68 mov %edx,0x68(%eax) <== NOT EXECUTED * the heap 1095dc: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax) <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 1095e3: 89 58 54 mov %ebx,0x54(%eax) <== NOT EXECUTED void *starting_address, size_t *size 1095e6: 5a pop %edx <== NOT EXECUTED 1095e7: 59 pop %ecx <== NOT EXECUTED 1095e8: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 1095eb: 50 push %eax <== NOT EXECUTED 1095ec: 68 e0 ca 11 00 push $0x11cae0 <== NOT EXECUTED 1095f1: e8 66 25 00 00 call 10bb5c <_Watchdog_Insert> <== NOT EXECUTED 1095f6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); } _Thread_Enable_dispatch(); 1095f9: e8 c2 17 00 00 call 10adc0 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 1095fe: 31 c0 xor %eax,%eax <== NOT EXECUTED 109600: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109603: c9 leave <== NOT EXECUTED 109604: c3 ret <== NOT EXECUTED 0010a124 : */ rtems_status_code rtems_task_wake_when( rtems_time_of_day *time_buffer ) { 10a124: 55 push %ebp <== NOT EXECUTED 10a125: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a127: 53 push %ebx <== NOT EXECUTED 10a128: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a12b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Watchdog_Interval seconds; if ( !_TOD_Is_set ) 10a12e: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 10a133: 80 3d d8 f4 11 00 00 cmpb $0x0,0x11f4d8 <== NOT EXECUTED 10a13a: 0f 84 9e 00 00 00 je 10a1de <== NOT EXECUTED return RTEMS_NOT_DEFINED; if ( !time_buffer ) 10a140: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a145: 85 db test %ebx,%ebx <== NOT EXECUTED 10a147: 0f 84 91 00 00 00 je 10a1de <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; time_buffer->ticks = 0; 10a14d: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED if ( !_TOD_Validate( time_buffer ) ) 10a154: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a157: 53 push %ebx <== NOT EXECUTED 10a158: e8 d7 f4 ff ff call 109634 <_TOD_Validate> <== NOT EXECUTED 10a15d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a160: 84 c0 test %al,%al <== NOT EXECUTED 10a162: 74 75 je 10a1d9 <== NOT EXECUTED return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); 10a164: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a167: 53 push %ebx <== NOT EXECUTED 10a168: e8 5f f4 ff ff call 1095cc <_TOD_To_seconds> <== NOT EXECUTED 10a16d: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( seconds <= _TOD_Seconds_since_epoch ) 10a16f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a172: 3b 05 54 f5 11 00 cmp 0x11f554,%eax <== NOT EXECUTED 10a178: 76 5f jbe 10a1d9 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a17a: a1 c4 f4 11 00 mov 0x11f4c4,%eax <== NOT EXECUTED 10a17f: 40 inc %eax <== NOT EXECUTED 10a180: a3 c4 f4 11 00 mov %eax,0x11f4c4 <== NOT EXECUTED return RTEMS_INVALID_CLOCK; _Thread_Disable_dispatch(); _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME ); 10a185: 50 push %eax <== NOT EXECUTED 10a186: 50 push %eax <== NOT EXECUTED 10a187: 6a 10 push $0x10 <== NOT EXECUTED 10a189: ff 35 84 f5 11 00 pushl 0x11f584 <== NOT EXECUTED 10a18f: e8 84 20 00 00 call 10c218 <_Thread_Set_state> <== NOT EXECUTED _Watchdog_Initialize( 10a194: a1 84 f5 11 00 mov 0x11f584,%eax <== NOT EXECUTED 10a199: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10a19c: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10a1a3: c7 40 64 ac b8 10 00 movl $0x10b8ac,0x64(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10a1aa: 89 50 68 mov %edx,0x68(%eax) <== NOT EXECUTED * the heap 10a1ad: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax) <== NOT EXECUTED * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. */ bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, 10a1b4: 2b 1d 54 f5 11 00 sub 0x11f554,%ebx <== NOT EXECUTED 10a1ba: 89 58 54 mov %ebx,0x54(%eax) <== NOT EXECUTED size_t size ); 10a1bd: 5a pop %edx <== NOT EXECUTED 10a1be: 59 pop %ecx <== NOT EXECUTED 10a1bf: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 10a1c2: 50 push %eax <== NOT EXECUTED 10a1c3: 68 98 f5 11 00 push $0x11f598 <== NOT EXECUTED 10a1c8: e8 63 26 00 00 call 10c830 <_Watchdog_Insert> <== NOT EXECUTED ); _Watchdog_Insert_seconds( &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); 10a1cd: e8 56 18 00 00 call 10ba28 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a1d2: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a1d4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a1d7: eb 05 jmp 10a1de <== NOT EXECUTED return RTEMS_SUCCESSFUL; 10a1d9: b8 14 00 00 00 mov $0x14,%eax <== NOT EXECUTED } 10a1de: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a1e1: c9 leave <== NOT EXECUTED 10a1e2: c3 ret <== NOT EXECUTED 00112aac : */ rtems_status_code rtems_timer_cancel( Objects_Id id ) { 112aac: 55 push %ebp <== NOT EXECUTED 112aad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112aaf: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 112ab2: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 112ab5: 50 push %eax <== NOT EXECUTED 112ab6: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112ab9: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112abe: e8 69 24 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 112ac3: 89 c2 mov %eax,%edx <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112ac5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112ac8: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112acd: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) <== NOT EXECUTED 112ad1: 75 1c jne 112aef <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 112ad3: 83 7a 38 04 cmpl $0x4,0x38(%edx) <== NOT EXECUTED 112ad7: 74 0f je 112ae8 <== NOT EXECUTED (void) _Watchdog_Remove( &the_timer->Ticker ); 112ad9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112adc: 8d 42 10 lea 0x10(%edx),%eax <== NOT EXECUTED 112adf: 50 push %eax <== NOT EXECUTED 112ae0: e8 3b 3e 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED 112ae5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Enable_dispatch(); 112ae8: e8 ff 2b 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112aed: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112aef: c9 leave <== NOT EXECUTED 112af0: c3 ret <== NOT EXECUTED 00112af4 : rtems_status_code rtems_timer_create( rtems_name name, Objects_Id *id ) { 112af4: 55 push %ebp <== NOT EXECUTED 112af5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112af7: 57 push %edi <== NOT EXECUTED 112af8: 56 push %esi <== NOT EXECUTED 112af9: 53 push %ebx <== NOT EXECUTED 112afa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112afd: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 112b00: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 112b03: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 112b08: 85 f6 test %esi,%esi <== NOT EXECUTED 112b0a: 74 73 je 112b7f <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 112b0c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 112b11: 85 ff test %edi,%edi <== NOT EXECUTED 112b13: 74 6a je 112b7f <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 112b15: a1 e0 27 13 00 mov 0x1327e0,%eax <== NOT EXECUTED 112b1a: 40 inc %eax <== NOT EXECUTED 112b1b: a3 e0 27 13 00 mov %eax,0x1327e0 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 112b20: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112b23: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112b28: e8 7f 1f 00 00 call 114aac <_Objects_Allocate> <== NOT EXECUTED 112b2d: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { 112b2f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112b32: 85 c0 test %eax,%eax <== NOT EXECUTED 112b34: 75 0c jne 112b42 <== NOT EXECUTED _Thread_Enable_dispatch(); 112b36: e8 b1 2b 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112b3b: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 112b40: eb 3d jmp 112b7f <== NOT EXECUTED return RTEMS_TOO_MANY; } the_timer->the_class = TIMER_DORMANT; 112b42: c7 40 38 04 00 00 00 movl $0x4,0x38(%eax) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 112b49: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 112b50: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 112b57: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) <== NOT EXECUTED * the heap 112b5e: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) <== NOT EXECUTED 112b65: 8b 48 08 mov 0x8(%eax),%ecx <== NOT EXECUTED 112b68: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 112b6b: a1 f0 2a 13 00 mov 0x132af0,%eax <== NOT EXECUTED 112b70: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 112b73: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Timer_Information, &the_timer->Object, (Objects_Name) name ); *id = the_timer->Object.id; 112b76: 89 0f mov %ecx,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 112b78: e8 6f 2b 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112b7d: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 112b7f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112b82: 5b pop %ebx <== NOT EXECUTED 112b83: 5e pop %esi <== NOT EXECUTED 112b84: 5f pop %edi <== NOT EXECUTED 112b85: c9 leave <== NOT EXECUTED 112b86: c3 ret <== NOT EXECUTED 00112b88 : */ rtems_status_code rtems_timer_delete( Objects_Id id ) { 112b88: 55 push %ebp <== NOT EXECUTED 112b89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112b8b: 53 push %ebx <== NOT EXECUTED 112b8c: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 112b8f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 112b92: 50 push %eax <== NOT EXECUTED 112b93: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112b96: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112b9b: e8 8c 23 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 112ba0: 89 c3 mov %eax,%ebx <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112ba2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112ba5: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112baa: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 112bae: 75 2f jne 112bdf <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Timer_Information, &the_timer->Object ); 112bb0: 51 push %ecx <== NOT EXECUTED 112bb1: 51 push %ecx <== NOT EXECUTED 112bb2: 53 push %ebx <== NOT EXECUTED 112bb3: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112bb8: e8 63 1f 00 00 call 114b20 <_Objects_Close> <== NOT EXECUTED (void) _Watchdog_Remove( &the_timer->Ticker ); 112bbd: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 112bc0: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 112bc3: e8 58 3d 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 112bc8: 58 pop %eax <== NOT EXECUTED 112bc9: 5a pop %edx <== NOT EXECUTED 112bca: 53 push %ebx <== NOT EXECUTED 112bcb: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112bd0: e8 e7 21 00 00 call 114dbc <_Objects_Free> <== NOT EXECUTED _Timer_Free( the_timer ); _Thread_Enable_dispatch(); 112bd5: e8 12 2b 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112bda: 31 c0 xor %eax,%eax <== NOT EXECUTED 112bdc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112bdf: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112be2: c9 leave <== NOT EXECUTED 112be3: c3 ret <== NOT EXECUTED 00112be4 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 112be4: 55 push %ebp <== NOT EXECUTED 112be5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112be7: 57 push %edi <== NOT EXECUTED 112be8: 56 push %esi <== NOT EXECUTED 112be9: 53 push %ebx <== NOT EXECUTED 112bea: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 112bed: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 112bf0: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 112bf5: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 112bf9: 0f 84 8e 00 00 00 je 112c8d <== NOT EXECUTED return RTEMS_INVALID_NUMBER; if ( !routine ) 112bff: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 112c04: 85 ff test %edi,%edi <== NOT EXECUTED 112c06: 0f 84 81 00 00 00 je 112c8d <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 112c0c: 52 push %edx <== NOT EXECUTED 112c0d: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 112c10: 50 push %eax <== NOT EXECUTED 112c11: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112c14: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112c19: e8 0e 23 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 112c1e: 89 c3 mov %eax,%ebx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112c20: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112c23: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112c28: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 112c2c: 75 5f jne 112c8d <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 112c2e: 8d 73 10 lea 0x10(%ebx),%esi <== NOT EXECUTED 112c31: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112c34: 56 push %esi <== NOT EXECUTED 112c35: e8 e6 3c 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED _ISR_Disable( level ); 112c3a: 9c pushf <== NOT EXECUTED 112c3b: fa cli <== NOT EXECUTED 112c3c: 5a pop %edx <== NOT EXECUTED /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { 112c3d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112c40: 83 7b 18 00 cmpl $0x0,0x18(%ebx) <== NOT EXECUTED 112c44: 74 0b je 112c51 <== NOT EXECUTED _ISR_Enable( level ); 112c46: 52 push %edx <== NOT EXECUTED 112c47: 9d popf <== NOT EXECUTED _Thread_Enable_dispatch(); 112c48: e8 9f 2a 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112c4d: 31 c0 xor %eax,%eax <== NOT EXECUTED 112c4f: eb 3c jmp 112c8d <== NOT EXECUTED /* * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ the_timer->the_class = TIMER_INTERVAL; 112c51: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 112c58: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 112c5f: 89 7b 2c mov %edi,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 112c62: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 112c65: 89 43 30 mov %eax,0x30(%ebx) <== NOT EXECUTED * the heap 112c68: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 112c6b: 89 43 34 mov %eax,0x34(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 112c6e: 52 push %edx <== NOT EXECUTED 112c6f: 9d popf <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 112c70: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 112c73: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 112c76: 50 push %eax <== NOT EXECUTED 112c77: 50 push %eax <== NOT EXECUTED 112c78: 56 push %esi <== NOT EXECUTED 112c79: 68 c0 28 13 00 push $0x1328c0 <== NOT EXECUTED 112c7e: e8 85 3b 00 00 call 116808 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 112c83: e8 64 2a 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112c88: 31 c0 xor %eax,%eax <== NOT EXECUTED 112c8a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112c8d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112c90: 5b pop %ebx <== NOT EXECUTED 112c91: 5e pop %esi <== NOT EXECUTED 112c92: 5f pop %edi <== NOT EXECUTED 112c93: c9 leave <== NOT EXECUTED 112c94: c3 ret <== NOT EXECUTED 00112c98 : Objects_Id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 112c98: 55 push %ebp <== NOT EXECUTED 112c99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112c9b: 57 push %edi <== NOT EXECUTED 112c9c: 56 push %esi <== NOT EXECUTED 112c9d: 53 push %ebx <== NOT EXECUTED 112c9e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 112ca1: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD_Is_set ) 112ca4: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 112ca9: 80 3d f4 27 13 00 00 cmpb $0x0,0x1327f4 <== NOT EXECUTED 112cb0: 0f 84 ae 00 00 00 je 112d64 <== NOT EXECUTED return RTEMS_NOT_DEFINED; if ( !_TOD_Validate( wall_time ) ) 112cb6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112cb9: 53 push %ebx <== NOT EXECUTED 112cba: e8 85 da ff ff call 110744 <_TOD_Validate> <== NOT EXECUTED 112cbf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112cc2: 84 c0 test %al,%al <== NOT EXECUTED 112cc4: 0f 84 95 00 00 00 je 112d5f <== NOT EXECUTED return RTEMS_INVALID_CLOCK; if ( !routine ) 112cca: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 112ccf: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 112cd3: 0f 84 8b 00 00 00 je 112d64 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; seconds = _TOD_To_seconds( wall_time ); 112cd9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112cdc: 53 push %ebx <== NOT EXECUTED 112cdd: e8 fa d9 ff ff call 1106dc <_TOD_To_seconds> <== NOT EXECUTED 112ce2: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( seconds <= _TOD_Seconds_since_epoch ) 112ce4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112ce7: 3b 05 70 28 13 00 cmp 0x132870,%eax <== NOT EXECUTED 112ced: 76 70 jbe 112d5f <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 112cef: 51 push %ecx <== NOT EXECUTED 112cf0: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 112cf3: 50 push %eax <== NOT EXECUTED 112cf4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112cf7: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112cfc: e8 2b 22 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 112d01: 89 c6 mov %eax,%esi <== NOT EXECUTED return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112d03: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112d06: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112d0b: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 112d0f: 75 53 jne 112d64 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 112d11: 8d 5e 10 lea 0x10(%esi),%ebx <== NOT EXECUTED 112d14: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112d17: 53 push %ebx <== NOT EXECUTED 112d18: e8 03 3c 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED the_timer->the_class = TIMER_TIME_OF_DAY; 112d1d: c7 46 38 02 00 00 00 movl $0x2,0x38(%esi) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 112d24: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 112d2b: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 112d2e: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 112d31: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 112d34: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED * the heap 112d37: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 112d3a: 89 46 34 mov %eax,0x34(%esi) <== NOT EXECUTED * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. */ bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, 112d3d: 2b 3d 70 28 13 00 sub 0x132870,%edi <== NOT EXECUTED 112d43: 89 7e 1c mov %edi,0x1c(%esi) <== NOT EXECUTED size_t size ); 112d46: 58 pop %eax <== NOT EXECUTED 112d47: 5a pop %edx <== NOT EXECUTED 112d48: 53 push %ebx <== NOT EXECUTED 112d49: 68 b4 28 13 00 push $0x1328b4 <== NOT EXECUTED 112d4e: e8 b5 3a 00 00 call 116808 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _Watchdog_Insert_seconds( &the_timer->Ticker, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); 112d53: e8 94 29 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112d58: 31 c0 xor %eax,%eax <== NOT EXECUTED 112d5a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112d5d: eb 05 jmp 112d64 <== NOT EXECUTED return RTEMS_SUCCESSFUL; 112d5f: b8 14 00 00 00 mov $0x14,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112d64: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112d67: 5b pop %ebx <== NOT EXECUTED 112d68: 5e pop %esi <== NOT EXECUTED 112d69: 5f pop %edi <== NOT EXECUTED 112d6a: c9 leave <== NOT EXECUTED 112d6b: c3 ret <== NOT EXECUTED 00112d6c : rtems_status_code rtems_timer_get_information( Objects_Id id, rtems_timer_information *the_info ) { 112d6c: 55 push %ebp <== NOT EXECUTED 112d6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112d6f: 53 push %ebx <== NOT EXECUTED 112d70: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 112d73: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 112d76: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 112d7b: 85 db test %ebx,%ebx <== NOT EXECUTED 112d7d: 74 40 je 112dbf <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 112d7f: 50 push %eax <== NOT EXECUTED 112d80: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 112d83: 50 push %eax <== NOT EXECUTED 112d84: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112d87: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112d8c: e8 9b 21 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 112d91: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112d93: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112d96: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112d9b: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 112d9f: 75 1e jne 112dbf <== NOT EXECUTED case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 112da1: 8b 42 38 mov 0x38(%edx),%eax <== NOT EXECUTED 112da4: 89 03 mov %eax,(%ebx) <== NOT EXECUTED the_info->initial = the_timer->Ticker.initial; 112da6: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 112da9: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED the_info->start_time = the_timer->Ticker.start_time; 112dac: 8b 42 24 mov 0x24(%edx),%eax <== NOT EXECUTED 112daf: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED the_info->stop_time = the_timer->Ticker.stop_time; 112db2: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 112db5: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 112db8: e8 2f 29 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112dbd: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112dbf: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112dc2: c9 leave <== NOT EXECUTED 112dc3: c3 ret <== NOT EXECUTED 00112dc4 : rtems_status_code rtems_timer_ident( rtems_name name, Objects_Id *id ) { 112dc4: 55 push %ebp <== NOT EXECUTED 112dc5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112dc7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 112dca: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 112dcd: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 112dd2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112dd5: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112dda: e8 95 22 00 00 call 115074 <_Objects_Name_to_id_u32> <== NOT EXECUTED 112ddf: 8b 04 85 58 7f 12 00 mov 0x127f58(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 112de6: c9 leave <== NOT EXECUTED 112de7: c3 ret <== NOT EXECUTED 0011301c : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 11301c: 55 push %ebp <== NOT EXECUTED 11301d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11301f: 57 push %edi <== NOT EXECUTED 113020: 56 push %esi <== NOT EXECUTED 113021: 53 push %ebx <== NOT EXECUTED 113022: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 113025: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 113028: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ); 11302b: 31 c0 xor %eax,%eax <== NOT EXECUTED 11302d: 85 d2 test %edx,%edx <== NOT EXECUTED 11302f: 74 0f je 113040 <== NOT EXECUTED 113031: 0f b6 05 e4 a0 12 00 movzbl 0x12a0e4,%eax <== NOT EXECUTED 113038: 39 c2 cmp %eax,%edx <== NOT EXECUTED 11303a: 0f 96 c0 setbe %al <== NOT EXECUTED 11303d: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED * Make sure the requested priority is valid. The if is * structured so we check it is invalid before looking for * a specific invalid value as the default. */ _priority = priority; if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) { 113040: 89 d7 mov %edx,%edi <== NOT EXECUTED 113042: 85 c0 test %eax,%eax <== NOT EXECUTED 113044: 75 0e jne 113054 <== NOT EXECUTED if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 113046: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED 11304b: 42 inc %edx <== NOT EXECUTED 11304c: 0f 85 31 01 00 00 jne 113183 <== NOT EXECUTED 113052: 31 ff xor %edi,%edi <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 113054: a1 e0 27 13 00 mov 0x1327e0,%eax <== NOT EXECUTED 113059: 40 inc %eax <== NOT EXECUTED 11305a: a3 e0 27 13 00 mov %eax,0x1327e0 <== NOT EXECUTED /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 11305f: 8a 1d 54 e2 12 00 mov 0x12e254,%bl <== NOT EXECUTED initialized = true; 113065: c6 05 54 e2 12 00 01 movb $0x1,0x12e254 <== NOT EXECUTED _Thread_Enable_dispatch(); 11306c: e8 7b 26 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED if ( tmpInitialized ) 113071: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 113076: 84 db test %bl,%bl <== NOT EXECUTED 113078: 0f 85 05 01 00 00 jne 113183 <== NOT EXECUTED 11307e: c7 05 74 27 13 00 78 movl $0x132778,0x132774 <== NOT EXECUTED 113085: 27 13 00 <== NOT EXECUTED 113088: c7 05 78 27 13 00 00 movl $0x0,0x132778 <== NOT EXECUTED 11308f: 00 00 00 <== NOT EXECUTED 113092: c7 05 7c 27 13 00 74 movl $0x132774,0x13277c <== NOT EXECUTED 113099: 27 13 00 <== NOT EXECUTED * other library rules. For example, if using a TSR written in Ada the * Server should run at the same priority as the priority Ada task. * Otherwise, the priority ceiling for the mutex used to protect the * GNAT run-time is violated. */ status = rtems_task_create( 11309c: 52 push %edx <== NOT EXECUTED 11309d: 52 push %edx <== NOT EXECUTED 11309e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 1130a1: 50 push %eax <== NOT EXECUTED 1130a2: 81 ce 00 80 00 00 or $0x8000,%esi <== NOT EXECUTED 1130a8: 56 push %esi <== NOT EXECUTED 1130a9: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 1130ae: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1130b1: 57 push %edi <== NOT EXECUTED 1130b2: 68 45 4d 49 54 push $0x54494d45 <== NOT EXECUTED 1130b7: e8 70 f3 ff ff call 11242c <== NOT EXECUTED /* user may want floating point but we need */ /* system task specified for 0 priority */ attribute_set | RTEMS_SYSTEM_TASK, &id /* get the id back */ ); if (status) { 1130bc: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1130bf: 85 c0 test %eax,%eax <== NOT EXECUTED 1130c1: 0f 85 b5 00 00 00 jne 11317c <== NOT EXECUTED * to a TCB pointer from here out. * * NOTE: Setting the pointer to the Timer Server TCB to a value other than * NULL indicates that task-based timer support is initialized. */ _Timer_Server = (Thread_Control *)_Objects_Get_local_object( 1130c7: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 1130ca: 31 c0 xor %eax,%eax <== NOT EXECUTED 1130cc: 66 3b 0d 24 27 13 00 cmp 0x132724,%cx <== NOT EXECUTED 1130d3: 77 0b ja 1130e0 <== NOT EXECUTED * This heap routine returns information about the free blocks * in the specified heap. 1130d5: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 1130d8: a1 30 27 13 00 mov 0x132730,%eax <== NOT EXECUTED 1130dd: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED 1130e0: a3 18 2b 13 00 mov %eax,0x132b18 <== NOT EXECUTED 1130e5: c7 05 54 27 13 00 58 movl $0x132758,0x132754 <== NOT EXECUTED 1130ec: 27 13 00 <== NOT EXECUTED 1130ef: c7 05 58 27 13 00 00 movl $0x0,0x132758 <== NOT EXECUTED 1130f6: 00 00 00 <== NOT EXECUTED 1130f9: c7 05 5c 27 13 00 54 movl $0x132754,0x13275c <== NOT EXECUTED 113100: 27 13 00 <== NOT EXECUTED 113103: c7 05 68 27 13 00 6c movl $0x13276c,0x132768 <== NOT EXECUTED 11310a: 27 13 00 <== NOT EXECUTED 11310d: c7 05 6c 27 13 00 00 movl $0x0,0x13276c <== NOT EXECUTED 113114: 00 00 00 <== NOT EXECUTED 113117: c7 05 70 27 13 00 68 movl $0x132768,0x132770 <== NOT EXECUTED 11311e: 27 13 00 <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 113121: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 113128: c7 40 64 70 55 11 00 movl $0x115570,0x64(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 11312f: 89 48 68 mov %ecx,0x68(%eax) <== NOT EXECUTED * the heap 113132: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 113139: c7 05 88 27 13 00 00 movl $0x0,0x132788 <== NOT EXECUTED 113140: 00 00 00 <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 113143: c7 05 9c 27 13 00 70 movl $0x115570,0x13279c <== NOT EXECUTED 11314a: 55 11 00 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 11314d: 89 0d a0 27 13 00 mov %ecx,0x1327a0 <== NOT EXECUTED * the heap 113153: c7 05 a4 27 13 00 00 movl $0x0,0x1327a4 <== NOT EXECUTED 11315a: 00 00 00 <== NOT EXECUTED /* * Initialize the pointer to the timer reset method so applications * that do not use the Timer Server do not have to pull it in. */ _Timer_Server_schedule_operation = _Timer_Server_schedule_operation_method; 11315d: c7 05 14 2b 13 00 8b movl $0x11318b,0x132b14 <== NOT EXECUTED 113164: 31 11 00 <== NOT EXECUTED /* * Start the timer server */ status = rtems_task_start( 113167: 50 push %eax <== NOT EXECUTED 113168: 6a 00 push $0x0 <== NOT EXECUTED 11316a: 68 14 32 11 00 push $0x113214 <== NOT EXECUTED 11316f: 51 push %ecx <== NOT EXECUTED 113170: e8 53 f7 ff ff call 1128c8 <== NOT EXECUTED id, /* the id from create */ (rtems_task_entry) _Timer_Server_body, /* the timer server entry point */ 0 /* there is no argument */ ); if (status) { 113175: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113178: 85 c0 test %eax,%eax <== NOT EXECUTED 11317a: 74 07 je 113183 <== NOT EXECUTED * but there is actually no way (in normal circumstances) that the * start can fail. The id and starting address are known to be * be good. If this service fails, something is weirdly wrong on the * target such as a stray write in an ISR or incorrect memory layout. */ initialized = false; 11317c: c6 05 54 e2 12 00 00 movb $0x0,0x12e254 <== NOT EXECUTED } return status; } 113183: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 113186: 5b pop %ebx <== NOT EXECUTED 113187: 5e pop %esi <== NOT EXECUTED 113188: 5f pop %edi <== NOT EXECUTED 113189: c9 leave <== NOT EXECUTED 11318a: c3 ret <== NOT EXECUTED 00112de8 : */ rtems_status_code rtems_timer_reset( Objects_Id id ) { 112de8: 55 push %ebp <== NOT EXECUTED 112de9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112deb: 53 push %ebx <== NOT EXECUTED 112dec: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 112def: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 112df2: 50 push %eax <== NOT EXECUTED 112df3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112df6: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112dfb: e8 2c 21 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 112e00: 89 c3 mov %eax,%ebx <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112e02: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112e05: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112e0a: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) <== NOT EXECUTED 112e0e: 75 6e jne 112e7e <== NOT EXECUTED case OBJECTS_LOCAL: switch ( the_timer->the_class ) { 112e10: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 112e13: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 112e16: 74 24 je 112e3c <== NOT EXECUTED 112e18: 72 07 jb 112e21 <== NOT EXECUTED 112e1a: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 112e1d: 77 58 ja 112e77 <== NOT EXECUTED 112e1f: eb 4a jmp 112e6b <== NOT EXECUTED case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); 112e21: 83 c3 10 add $0x10,%ebx <== NOT EXECUTED 112e24: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112e27: 53 push %ebx <== NOT EXECUTED 112e28: e8 f3 3a 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); 112e2d: 58 pop %eax <== NOT EXECUTED 112e2e: 5a pop %edx <== NOT EXECUTED 112e2f: 53 push %ebx <== NOT EXECUTED 112e30: 68 c0 28 13 00 push $0x1328c0 <== NOT EXECUTED 112e35: e8 ce 39 00 00 call 116808 <_Watchdog_Insert> <== NOT EXECUTED 112e3a: eb 2a jmp 112e66 <== NOT EXECUTED break; case TIMER_INTERVAL_ON_TASK: if ( !_Timer_Server_schedule_operation ) { 112e3c: 83 3d 14 2b 13 00 00 cmpl $0x0,0x132b14 <== NOT EXECUTED 112e43: 75 0c jne 112e51 <== NOT EXECUTED _Thread_Enable_dispatch(); 112e45: e8 a2 28 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112e4a: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 112e4f: eb 2d jmp 112e7e <== NOT EXECUTED return RTEMS_INCORRECT_STATE; } _Watchdog_Remove( &the_timer->Ticker ); 112e51: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112e54: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 112e57: 50 push %eax <== NOT EXECUTED 112e58: e8 c3 3a 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED (*_Timer_Server_schedule_operation)( the_timer ); 112e5d: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 112e60: ff 15 14 2b 13 00 call *0x132b14 <== NOT EXECUTED 112e66: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112e69: eb 0c jmp 112e77 <== NOT EXECUTED break; case TIMER_TIME_OF_DAY: case TIMER_TIME_OF_DAY_ON_TASK: case TIMER_DORMANT: _Thread_Enable_dispatch(); 112e6b: e8 7c 28 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112e70: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 112e75: eb 07 jmp 112e7e <== NOT EXECUTED return RTEMS_NOT_DEFINED; } _Thread_Enable_dispatch(); 112e77: e8 70 28 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112e7c: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112e7e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112e81: c9 leave <== NOT EXECUTED 112e82: c3 ret <== NOT EXECUTED 00112e84 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 112e84: 55 push %ebp <== NOT EXECUTED 112e85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112e87: 57 push %edi <== NOT EXECUTED 112e88: 56 push %esi <== NOT EXECUTED 112e89: 53 push %ebx <== NOT EXECUTED 112e8a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 112e8d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 112e90: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 112e93: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 112e98: 83 3d 18 2b 13 00 00 cmpl $0x0,0x132b18 <== NOT EXECUTED 112e9f: 0f 84 91 00 00 00 je 112f36 <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !routine ) 112ea5: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 112eaa: 85 f6 test %esi,%esi <== NOT EXECUTED 112eac: 0f 84 84 00 00 00 je 112f36 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 112eb2: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 112eb7: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 112ebb: 74 79 je 112f36 <== NOT EXECUTED 112ebd: 50 push %eax <== NOT EXECUTED 112ebe: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 112ec1: 50 push %eax <== NOT EXECUTED 112ec2: 57 push %edi <== NOT EXECUTED 112ec3: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112ec8: e8 5f 20 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 112ecd: 89 c3 mov %eax,%ebx <== NOT EXECUTED return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112ecf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112ed2: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112ed7: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 112edb: 75 59 jne 112f36 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 112edd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112ee0: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 112ee3: 50 push %eax <== NOT EXECUTED 112ee4: e8 37 3a 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED _ISR_Disable( level ); 112ee9: 9c pushf <== NOT EXECUTED 112eea: fa cli <== NOT EXECUTED 112eeb: 5a pop %edx <== NOT EXECUTED /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { 112eec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112eef: 83 7b 18 00 cmpl $0x0,0x18(%ebx) <== NOT EXECUTED 112ef3: 74 0b je 112f00 <== NOT EXECUTED _ISR_Enable( level ); 112ef5: 52 push %edx <== NOT EXECUTED 112ef6: 9d popf <== NOT EXECUTED _Thread_Enable_dispatch(); 112ef7: e8 f0 27 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112efc: 31 c0 xor %eax,%eax <== NOT EXECUTED 112efe: eb 36 jmp 112f36 <== NOT EXECUTED /* * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ the_timer->the_class = TIMER_INTERVAL_ON_TASK; 112f00: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 112f07: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 112f0e: 89 73 2c mov %esi,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 112f11: 89 7b 30 mov %edi,0x30(%ebx) <== NOT EXECUTED * the heap 112f14: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 112f17: 89 43 34 mov %eax,0x34(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = ticks; 112f1a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 112f1d: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 112f20: 52 push %edx <== NOT EXECUTED 112f21: 9d popf <== NOT EXECUTED /* * _Timer_Server_schedule_operation != NULL because we checked that * _Timer_Server was != NULL above. Both are set at the same time. */ (*_Timer_Server_schedule_operation)( the_timer ); 112f22: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112f25: 53 push %ebx <== NOT EXECUTED 112f26: ff 15 14 2b 13 00 call *0x132b14 <== NOT EXECUTED _Thread_Enable_dispatch(); 112f2c: e8 bb 27 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 112f31: 31 c0 xor %eax,%eax <== NOT EXECUTED 112f33: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112f36: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112f39: 5b pop %ebx <== NOT EXECUTED 112f3a: 5e pop %esi <== NOT EXECUTED 112f3b: 5f pop %edi <== NOT EXECUTED 112f3c: c9 leave <== NOT EXECUTED 112f3d: c3 ret <== NOT EXECUTED 00112f40 : Objects_Id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 112f40: 55 push %ebp <== NOT EXECUTED 112f41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112f43: 57 push %edi <== NOT EXECUTED 112f44: 56 push %esi <== NOT EXECUTED 112f45: 53 push %ebx <== NOT EXECUTED 112f46: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 112f49: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 112f4c: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_Timer_Server ) 112f4f: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 112f54: 83 3d 18 2b 13 00 00 cmpl $0x0,0x132b18 <== NOT EXECUTED 112f5b: 0f 84 b3 00 00 00 je 113014 <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 112f61: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 112f66: 80 3d f4 27 13 00 00 cmpb $0x0,0x1327f4 <== NOT EXECUTED 112f6d: 0f 84 a1 00 00 00 je 113014 <== NOT EXECUTED return RTEMS_NOT_DEFINED; if ( !routine ) 112f73: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 112f78: 85 ff test %edi,%edi <== NOT EXECUTED 112f7a: 0f 84 94 00 00 00 je 113014 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 112f80: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112f83: 53 push %ebx <== NOT EXECUTED 112f84: e8 bb d7 ff ff call 110744 <_TOD_Validate> <== NOT EXECUTED 112f89: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112f8c: 84 c0 test %al,%al <== NOT EXECUTED 112f8e: 74 7f je 11300f <== NOT EXECUTED return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 112f90: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112f93: 53 push %ebx <== NOT EXECUTED 112f94: e8 43 d7 ff ff call 1106dc <_TOD_To_seconds> <== NOT EXECUTED 112f99: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( seconds <= _TOD_Seconds_since_epoch ) 112f9b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112f9e: 3b 05 70 28 13 00 cmp 0x132870,%eax <== NOT EXECUTED 112fa4: 76 69 jbe 11300f <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 112fa6: 50 push %eax <== NOT EXECUTED 112fa7: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 112faa: 50 push %eax <== NOT EXECUTED 112fab: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112fae: 68 d4 2a 13 00 push $0x132ad4 <== NOT EXECUTED 112fb3: e8 74 1f 00 00 call 114f2c <_Objects_Get> <== NOT EXECUTED 112fb8: 89 c3 mov %eax,%ebx <== NOT EXECUTED return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112fba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112fbd: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 112fc2: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 112fc6: 75 4c jne 113014 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 112fc8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112fcb: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 112fce: 50 push %eax <== NOT EXECUTED 112fcf: e8 4c 39 00 00 call 116920 <_Watchdog_Remove> <== NOT EXECUTED the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 112fd4: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 112fdb: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 112fe2: 89 7b 2c mov %edi,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 112fe5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 112fe8: 89 43 30 mov %eax,0x30(%ebx) <== NOT EXECUTED * the heap 112feb: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 112fee: 89 43 34 mov %eax,0x34(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch; 112ff1: 2b 35 70 28 13 00 sub 0x132870,%esi <== NOT EXECUTED 112ff7: 89 73 1c mov %esi,0x1c(%ebx) <== NOT EXECUTED /* * _Timer_Server_schedule_operation != NULL because we checked that * _Timer_Server was != NULL above. Both are set at the same time. */ (*_Timer_Server_schedule_operation)( the_timer ); 112ffa: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 112ffd: ff 15 14 2b 13 00 call *0x132b14 <== NOT EXECUTED _Thread_Enable_dispatch(); 113003: e8 e4 26 00 00 call 1156ec <_Thread_Enable_dispatch> <== NOT EXECUTED 113008: 31 c0 xor %eax,%eax <== NOT EXECUTED 11300a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11300d: eb 05 jmp 113014 <== NOT EXECUTED return RTEMS_SUCCESSFUL; 11300f: b8 14 00 00 00 mov $0x14,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 113014: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 113017: 5b pop %ebx <== NOT EXECUTED 113018: 5e pop %esi <== NOT EXECUTED 113019: 5f pop %edi <== NOT EXECUTED 11301a: c9 leave <== NOT EXECUTED 11301b: c3 ret <== NOT EXECUTED