0010ac68 <_API_Mutex_Allocate>: #include void _API_Mutex_Allocate( API_Mutex_Control **the_mutex ) { 10ac68: 55 push %ebp <== NOT EXECUTED 10ac69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac6b: 57 push %edi <== NOT EXECUTED 10ac6c: 56 push %esi <== NOT EXECUTED 10ac6d: 53 push %ebx <== NOT EXECUTED 10ac6e: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED CORE_mutex_Attributes attr = { CORE_MUTEX_NESTING_IS_ERROR, FALSE, CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT, 0 }; 10ac71: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 10ac74: be c0 85 11 00 mov $0x1185c0,%esi <== NOT EXECUTED 10ac79: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10ac7e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED mutex = (API_Mutex_Control *) _Objects_Allocate( &_API_Mutex_Information ); 10ac80: 68 00 eb 11 00 push $0x11eb00 <== NOT EXECUTED 10ac85: e8 e6 08 00 00 call 10b570 <_Objects_Allocate> <== NOT EXECUTED 10ac8a: 89 c3 mov %eax,%ebx <== NOT EXECUTED _CORE_mutex_Initialize( &mutex->Mutex, &attr, CORE_MUTEX_UNLOCKED ); 10ac8c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ac8f: 6a 01 push $0x1 <== NOT EXECUTED 10ac91: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10ac94: 50 push %eax <== NOT EXECUTED 10ac95: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10ac98: 50 push %eax <== NOT EXECUTED 10ac99: e8 22 02 00 00 call 10aec0 <_CORE_mutex_Initialize> <== NOT EXECUTED 10ac9e: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 10aca2: a1 1c eb 11 00 mov 0x11eb1c,%eax <== NOT EXECUTED 10aca7: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10acaa: 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; 10acb1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10acb4: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10acb6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10acb9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10acbc: 5b pop %ebx <== NOT EXECUTED 10acbd: 5e pop %esi <== NOT EXECUTED 10acbe: 5f pop %edi <== NOT EXECUTED 10acbf: c9 leave <== NOT EXECUTED 10acc0: c3 ret <== NOT EXECUTED 0010ace8 <_API_Mutex_Initialization>: #include void _API_Mutex_Initialization( uint32_t maximum_mutexes ) { 10ace8: 55 push %ebp <== NOT EXECUTED 10ace9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aceb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10acee: 6a 00 push $0x0 <== NOT EXECUTED 10acf0: 6a 00 push $0x0 <== NOT EXECUTED 10acf2: 6a 74 push $0x74 <== NOT EXECUTED 10acf4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10acf7: 6a 02 push $0x2 <== NOT EXECUTED 10acf9: 6a 01 push $0x1 <== NOT EXECUTED 10acfb: 68 00 eb 11 00 push $0x11eb00 <== NOT EXECUTED 10ad00: e8 c3 0d 00 00 call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10ad05: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , TRUE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ad08: c9 leave <== NOT EXECUTED 10ad09: c3 ret <== NOT EXECUTED 0010acc4 <_API_Mutex_Lock>: #include void _API_Mutex_Lock( API_Mutex_Control *the_mutex ) { 10acc4: 55 push %ebp <== NOT EXECUTED 10acc5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10acc7: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10acca: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10accd: 9c pushf <== NOT EXECUTED 10acce: fa cli <== NOT EXECUTED 10accf: 5a pop %edx <== NOT EXECUTED _CORE_mutex_Seize( 10acd0: 52 push %edx <== NOT EXECUTED 10acd1: 6a 00 push $0x0 <== NOT EXECUTED 10acd3: 6a 01 push $0x1 <== NOT EXECUTED 10acd5: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10acd8: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10acdb: 50 push %eax <== NOT EXECUTED 10acdc: e8 d7 02 00 00 call 10afb8 <_CORE_mutex_Seize> <== NOT EXECUTED 10ace1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED the_mutex->Object.id, TRUE, 0, level ); } 10ace4: c9 leave <== NOT EXECUTED 10ace5: c3 ret <== NOT EXECUTED 0010ad0c <_API_Mutex_Unlock>: #include void _API_Mutex_Unlock( API_Mutex_Control *the_mutex ) { 10ad0c: 55 push %ebp <== NOT EXECUTED 10ad0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad0f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad12: 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 10ad15: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10ad1a: 40 inc %eax <== NOT EXECUTED 10ad1b: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED _Thread_Disable_dispatch(); _CORE_mutex_Surrender( 10ad20: 6a 00 push $0x0 <== NOT EXECUTED 10ad22: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED 10ad25: 83 c2 10 add $0x10,%edx <== NOT EXECUTED 10ad28: 52 push %edx <== NOT EXECUTED 10ad29: e8 26 03 00 00 call 10b054 <_CORE_mutex_Surrender> <== NOT EXECUTED &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 10ad2e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10ad31: c9 leave <== NOT EXECUTED _CORE_mutex_Surrender( &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 10ad32: e9 71 15 00 00 jmp 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED 0010ac50 <_API_extensions_Add>: */ void _API_extensions_Add( API_extensions_Control *the_extension ) { 10ac50: 55 push %ebp <== NOT EXECUTED 10ac51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac53: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED _Chain_Append( &_API_extensions_List, &the_extension->Node ); 10ac56: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ac59: 68 58 ec 11 00 push $0x11ec58 <== NOT EXECUTED 10ac5e: e8 d5 00 00 00 call 10ad38 <_Chain_Append> <== NOT EXECUTED 10ac63: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10ac66: c9 leave <== NOT EXECUTED 10ac67: c3 ret <== NOT EXECUTED 0010ab90 <_API_extensions_Initialization>: * * _API_extensions_Initialization */ void _API_extensions_Initialization( void ) { 10ab90: 55 push %ebp <== NOT EXECUTED 10ab91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ab93: c7 05 58 ec 11 00 5c movl $0x11ec5c,0x11ec58 <== NOT EXECUTED 10ab9a: ec 11 00 <== NOT EXECUTED 10ab9d: c7 05 5c ec 11 00 00 movl $0x0,0x11ec5c <== NOT EXECUTED 10aba4: 00 00 00 <== NOT EXECUTED 10aba7: c7 05 60 ec 11 00 58 movl $0x11ec58,0x11ec60 <== NOT EXECUTED 10abae: ec 11 00 <== NOT EXECUTED _Chain_Initialize_empty( &_API_extensions_List ); } 10abb1: c9 leave <== NOT EXECUTED 10abb2: c3 ret <== NOT EXECUTED 0010abe4 <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 10abe4: 55 push %ebp <== NOT EXECUTED 10abe5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10abe7: 53 push %ebx <== NOT EXECUTED 10abe8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10abeb: 8b 1d 58 ec 11 00 mov 0x11ec58,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10abf1: 81 fb 5c ec 11 00 cmp $0x11ec5c,%ebx <== NOT EXECUTED 10abf7: 74 16 je 10ac0f <_API_extensions_Run_postdriver+0x2b> <== NOT EXECUTED 10abf9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) 10abfc: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10abff: 85 c0 test %eax,%eax <== NOT EXECUTED 10ac01: 74 02 je 10ac05 <_API_extensions_Run_postdriver+0x21> <== NOT EXECUTED (*the_extension->postdriver_hook)(); 10ac03: 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 ) { 10ac05: 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 ) ; 10ac07: 81 fb 5c ec 11 00 cmp $0x11ec5c,%ebx <== NOT EXECUTED 10ac0d: 75 ed jne 10abfc <_API_extensions_Run_postdriver+0x18> <== NOT EXECUTED the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) (*the_extension->postdriver_hook)(); } } 10ac0f: 5a pop %edx <== NOT EXECUTED 10ac10: 5b pop %ebx <== NOT EXECUTED 10ac11: c9 leave <== NOT EXECUTED 10ac12: c3 ret <== NOT EXECUTED 0010ac14 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 10ac14: 55 push %ebp <== NOT EXECUTED 10ac15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac17: 53 push %ebx <== NOT EXECUTED 10ac18: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10ac1b: 8b 1d 58 ec 11 00 mov 0x11ec58,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10ac21: 81 fb 5c ec 11 00 cmp $0x11ec5c,%ebx <== NOT EXECUTED 10ac27: 74 22 je 10ac4b <_API_extensions_Run_postswitch+0x37> <== NOT EXECUTED 10ac29: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) 10ac2c: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10ac2f: 85 c0 test %eax,%eax <== NOT EXECUTED 10ac31: 74 0e je 10ac41 <_API_extensions_Run_postswitch+0x2d> <== NOT EXECUTED (*the_extension->postswitch_hook)( _Thread_Executing ); 10ac33: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ac36: ff 35 bc ea 11 00 pushl 0x11eabc <== NOT EXECUTED 10ac3c: ff d0 call *%eax <== NOT EXECUTED 10ac3e: 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 ) { 10ac41: 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 ) ; 10ac43: 81 fb 5c ec 11 00 cmp $0x11ec5c,%ebx <== NOT EXECUTED 10ac49: 75 e1 jne 10ac2c <_API_extensions_Run_postswitch+0x18> <== NOT EXECUTED the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) (*the_extension->postswitch_hook)( _Thread_Executing ); } } 10ac4b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ac4e: c9 leave <== NOT EXECUTED 10ac4f: c3 ret <== NOT EXECUTED 0010abb4 <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 10abb4: 55 push %ebp <== NOT EXECUTED 10abb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10abb7: 53 push %ebx <== NOT EXECUTED 10abb8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10abbb: 8b 1d 58 ec 11 00 mov 0x11ec58,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10abc1: 81 fb 5c ec 11 00 cmp $0x11ec5c,%ebx <== NOT EXECUTED 10abc7: 74 16 je 10abdf <_API_extensions_Run_predriver+0x2b> <== NOT EXECUTED 10abc9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) 10abcc: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10abcf: 85 c0 test %eax,%eax <== NOT EXECUTED 10abd1: 74 02 je 10abd5 <_API_extensions_Run_predriver+0x21> <== NOT EXECUTED (*the_extension->predriver_hook)(); 10abd3: 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 ) { 10abd5: 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 ) ; 10abd7: 81 fb 5c ec 11 00 cmp $0x11ec5c,%ebx <== NOT EXECUTED 10abdd: 75 ed jne 10abcc <_API_extensions_Run_predriver+0x18> <== NOT EXECUTED the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) (*the_extension->predriver_hook)(); } } 10abdf: 58 pop %eax <== NOT EXECUTED 10abe0: 5b pop %ebx <== NOT EXECUTED 10abe1: c9 leave <== NOT EXECUTED 10abe2: c3 ret <== NOT EXECUTED 0010ebb4 <_Barrier_Manager_initialization>: */ void _Barrier_Manager_initialization( uint32_t maximum_barriers ) { 10ebb4: 55 push %ebp <== NOT EXECUTED 10ebb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ebb7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ebba: 6a 04 push $0x4 <== NOT EXECUTED 10ebbc: 6a 00 push $0x0 <== NOT EXECUTED 10ebbe: 6a 60 push $0x60 <== NOT EXECUTED 10ebc0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ebc3: 6a 0a push $0xa <== NOT EXECUTED 10ebc5: 6a 02 push $0x2 <== NOT EXECUTED 10ebc7: 68 c0 ed 11 00 push $0x11edc0 <== NOT EXECUTED 10ebcc: e8 f7 ce ff ff call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10ebd1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ebd4: c9 leave <== NOT EXECUTED 10ebd5: c3 ret <== NOT EXECUTED 0010fbf0 <_Barrier_Translate_core_barrier_return_code>: }; rtems_status_code _Barrier_Translate_core_barrier_return_code ( CORE_barrier_Status the_barrier_status ) { 10fbf0: 55 push %ebp <== NOT EXECUTED 10fbf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fbf3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10fbf6: 8b 04 85 b8 f4 11 00 mov 0x11f4b8(,%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]; } 10fbfd: c9 leave <== NOT EXECUTED 10fbfe: c3 ret <== NOT EXECUTED 0010bc1c <_CORE_barrier_Initialize>: void _CORE_barrier_Initialize( CORE_barrier_Control *the_barrier, CORE_barrier_Attributes *the_barrier_attributes ) { 10bc1c: 55 push %ebp <== NOT EXECUTED 10bc1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc1f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bc22: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bc25: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED the_barrier->Attributes = *the_barrier_attributes; 10bc28: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10bc2a: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10bc2d: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED 10bc30: 89 4a 40 mov %ecx,0x40(%edx) <== NOT EXECUTED the_barrier->number_of_waiting_threads = 0; 10bc33: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) <== NOT EXECUTED _Thread_queue_Initialize( 10bc3a: 6a 03 push $0x3 <== NOT EXECUTED 10bc3c: 68 00 00 01 00 push $0x10000 <== NOT EXECUTED 10bc41: 6a 00 push $0x0 <== NOT EXECUTED 10bc43: 52 push %edx <== NOT EXECUTED 10bc44: e8 13 1d 00 00 call 10d95c <_Thread_queue_Initialize> <== NOT EXECUTED 10bc49: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &the_barrier->Wait_queue, THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_BARRIER, CORE_BARRIER_TIMEOUT ); } 10bc4c: c9 leave <== NOT EXECUTED 10bc4d: c3 ret <== NOT EXECUTED 0010bc50 <_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 ) { 10bc50: 55 push %ebp <== NOT EXECUTED 10bc51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc53: 56 push %esi <== NOT EXECUTED 10bc54: 53 push %ebx <== NOT EXECUTED 10bc55: 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)) ) { 10bc58: 31 db xor %ebx,%ebx <== NOT EXECUTED 10bc5a: eb 01 jmp 10bc5d <_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++; 10bc5c: 43 inc %ebx <== NOT EXECUTED { Thread_Control *the_thread; uint32_t count; count = 0; while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) { 10bc5d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bc60: 56 push %esi <== NOT EXECUTED 10bc61: e8 46 19 00 00 call 10d5ac <_Thread_queue_Dequeue> <== NOT EXECUTED 10bc66: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bc69: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc6b: 75 ef jne 10bc5c <_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; 10bc6d: c7 46 48 00 00 00 00 movl $0x0,0x48(%esi) <== NOT EXECUTED return count; } 10bc74: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bc76: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10bc79: 5b pop %ebx <== NOT EXECUTED 10bc7a: 5e pop %esi <== NOT EXECUTED 10bc7b: c9 leave <== NOT EXECUTED 10bc7c: c3 ret <== NOT EXECUTED 0010bc80 <_CORE_barrier_Wait>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 10bc80: 55 push %ebp <== NOT EXECUTED 10bc81: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc83: 57 push %edi <== NOT EXECUTED 10bc84: 56 push %esi <== NOT EXECUTED 10bc85: 53 push %ebx <== NOT EXECUTED 10bc86: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bc89: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bc8c: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10bc8f: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 10bc92: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10bc95: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 10bc98: 8b 0d bc 17 12 00 mov 0x1217bc,%ecx <== NOT EXECUTED executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; 10bc9e: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) <== NOT EXECUTED _ISR_Disable( level ); 10bca5: 9c pushf <== NOT EXECUTED 10bca6: fa cli <== NOT EXECUTED 10bca7: 5b pop %ebx <== NOT EXECUTED the_barrier->number_of_waiting_threads++; 10bca8: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED 10bcab: 40 inc %eax <== NOT EXECUTED 10bcac: 89 42 48 mov %eax,0x48(%edx) <== NOT EXECUTED if ( the_barrier->number_of_waiting_threads == 10bcaf: 3b 42 44 cmp 0x44(%edx),%eax <== NOT EXECUTED 10bcb2: 75 07 jne 10bcbb <_CORE_barrier_Wait+0x3b> <== NOT EXECUTED the_barrier->Attributes.maximum_count) { if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { 10bcb4: 8b 42 40 mov 0x40(%edx),%eax <== NOT EXECUTED 10bcb7: 85 c0 test %eax,%eax <== NOT EXECUTED 10bcb9: 74 29 je 10bce4 <_CORE_barrier_Wait+0x64> <== 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 10bcbb: 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; 10bcc2: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED executing->Wait.id = id; 10bcc5: 89 79 20 mov %edi,0x20(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10bcc8: 53 push %ebx <== NOT EXECUTED 10bcc9: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); 10bcca: c7 45 10 38 da 10 00 movl $0x10da38,0x10(%ebp) <== NOT EXECUTED 10bcd1: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10bcd4: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10bcd7: 58 pop %eax <== NOT EXECUTED 10bcd8: 5b pop %ebx <== NOT EXECUTED 10bcd9: 5e pop %esi <== NOT EXECUTED 10bcda: 5f pop %edi <== NOT EXECUTED 10bcdb: 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 ); 10bcdc: e9 07 1a 00 00 jmp 10d6e8 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 10bce1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _ISR_Disable( level ); the_barrier->number_of_waiting_threads++; 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; 10bce4: c7 41 34 01 00 00 00 movl $0x1,0x34(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10bceb: 53 push %ebx <== NOT EXECUTED 10bcec: 9d popf <== NOT EXECUTED _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support ); 10bced: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10bcf0: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 10bcf3: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED 10bcf6: 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 ); } 10bcf9: 5a pop %edx <== NOT EXECUTED 10bcfa: 5b pop %ebx <== NOT EXECUTED 10bcfb: 5e pop %esi <== NOT EXECUTED 10bcfc: 5f pop %edi <== NOT EXECUTED 10bcfd: 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 ); 10bcfe: e9 4d ff ff ff jmp 10bc50 <_CORE_barrier_Release> <== NOT EXECUTED 001154f8 <_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 ) { 1154f8: 55 push %ebp <== NOT EXECUTED 1154f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1154fb: 57 push %edi <== NOT EXECUTED 1154fc: 56 push %esi <== NOT EXECUTED 1154fd: 53 push %ebx <== NOT EXECUTED 1154fe: 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 ) { 115501: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 115504: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 115507: 39 50 4c cmp %edx,0x4c(%eax) <== NOT EXECUTED 11550a: 72 58 jb 115564 <_CORE_message_queue_Broadcast+0x6c> <== 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 ) { 11550c: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 11550f: 8b 46 48 mov 0x48(%esi),%eax <== NOT EXECUTED 115512: 85 c0 test %eax,%eax <== NOT EXECUTED 115514: 75 3a jne 115550 <_CORE_message_queue_Broadcast+0x58> <== 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))) { 115516: 31 db xor %ebx,%ebx <== NOT EXECUTED 115518: eb 16 jmp 115530 <_CORE_message_queue_Broadcast+0x38> <== NOT EXECUTED 11551a: 66 90 xchg %ax,%ax <== NOT EXECUTED waitp = &the_thread->Wait; number_broadcasted += 1; 11551c: 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 11551d: 8b 78 2c mov 0x2c(%eax),%edi <== NOT EXECUTED 115520: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 115523: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 115526: 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; 115528: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 11552b: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 11552e: 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))) { 115530: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 115533: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 115536: e8 29 22 00 00 call 117764 <_Thread_queue_Dequeue> <== NOT EXECUTED 11553b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11553e: 85 c0 test %eax,%eax <== NOT EXECUTED 115540: 75 da jne 11551c <_CORE_message_queue_Broadcast+0x24> <== NOT EXECUTED if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_message_queue_mp_support) ( the_thread, id ); #endif } *count = number_broadcasted; 115542: 8b 75 1c mov 0x1c(%ebp),%esi <== NOT EXECUTED 115545: 89 1e mov %ebx,(%esi) <== NOT EXECUTED return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 115547: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11554a: 5b pop %ebx <== NOT EXECUTED 11554b: 5e pop %esi <== NOT EXECUTED 11554c: 5f pop %edi <== NOT EXECUTED 11554d: c9 leave <== NOT EXECUTED 11554e: c3 ret <== NOT EXECUTED 11554f: 90 nop <== NOT EXECUTED * 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 ) { *count = 0; 115550: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 115553: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 115559: 31 c0 xor %eax,%eax <== NOT EXECUTED #endif } *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 11555b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11555e: 5b pop %ebx <== NOT EXECUTED 11555f: 5e pop %esi <== NOT EXECUTED 115560: 5f pop %edi <== NOT EXECUTED 115561: c9 leave <== NOT EXECUTED 115562: c3 ret <== NOT EXECUTED 115563: 90 nop <== NOT EXECUTED { Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 115564: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED #endif } *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 115569: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11556c: 5b pop %ebx <== NOT EXECUTED 11556d: 5e pop %esi <== NOT EXECUTED 11556e: 5f pop %edi <== NOT EXECUTED 11556f: c9 leave <== NOT EXECUTED 115570: c3 ret <== NOT EXECUTED 00115dec <_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 ) { 115dec: 55 push %ebp <== NOT EXECUTED 115ded: 89 e5 mov %esp,%ebp <== NOT EXECUTED 115def: 53 push %ebx <== NOT EXECUTED 115df0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 115df3: 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( 115df6: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 115df9: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 115dfc: 53 push %ebx <== NOT EXECUTED 115dfd: e8 e6 b9 ff ff call 1117e8 <_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 ) 115e02: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115e05: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 115e08: 85 c0 test %eax,%eax <== NOT EXECUTED 115e0a: 74 0c je 115e18 <_CORE_message_queue_Close+0x2c> <== NOT EXECUTED (void) _CORE_message_queue_Flush_support( the_message_queue ); 115e0c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 115e0f: 53 push %ebx <== NOT EXECUTED 115e10: e8 13 00 00 00 call 115e28 <_CORE_message_queue_Flush_support> <== NOT EXECUTED 115e15: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (void) _Workspace_Free( the_message_queue->message_buffers ); 115e18: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED 115e1b: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 115e1e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 115e21: 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 ); 115e22: e9 65 c4 ff ff jmp 11228c <_Workspace_Free> <== NOT EXECUTED 001155b0 <_CORE_message_queue_Flush>: */ uint32_t _CORE_message_queue_Flush( CORE_message_queue_Control *the_message_queue ) { 1155b0: 55 push %ebp <== NOT EXECUTED 1155b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1155b3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages != 0 ) 1155b6: 8b 50 48 mov 0x48(%eax),%edx <== NOT EXECUTED 1155b9: 85 d2 test %edx,%edx <== NOT EXECUTED 1155bb: 75 07 jne 1155c4 <_CORE_message_queue_Flush+0x14> <== NOT EXECUTED return _CORE_message_queue_Flush_support( the_message_queue ); else return 0; } 1155bd: 31 c0 xor %eax,%eax <== NOT EXECUTED 1155bf: c9 leave <== NOT EXECUTED 1155c0: c3 ret <== NOT EXECUTED 1155c1: 8d 76 00 lea 0x0(%esi),%esi <== 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 ); 1155c4: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED else return 0; } 1155c7: 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 ); 1155c8: e9 03 00 00 00 jmp 1155d0 <_CORE_message_queue_Flush_support> <== NOT EXECUTED 00115e28 <_CORE_message_queue_Flush_support>: */ uint32_t _CORE_message_queue_Flush_support( CORE_message_queue_Control *the_message_queue ) { 115e28: 55 push %ebp <== NOT EXECUTED 115e29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 115e2b: 56 push %esi <== NOT EXECUTED 115e2c: 53 push %ebx <== NOT EXECUTED 115e2d: 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 ); 115e30: 9c pushf <== NOT EXECUTED 115e31: fa cli <== NOT EXECUTED 115e32: 5e pop %esi <== NOT EXECUTED inactive_first = the_message_queue->Inactive_messages.first; 115e33: 8b 4a 68 mov 0x68(%edx),%ecx <== NOT EXECUTED message_queue_first = the_message_queue->Pending_messages.first; 115e36: 8b 5a 50 mov 0x50(%edx),%ebx <== NOT EXECUTED message_queue_last = the_message_queue->Pending_messages.last; 115e39: 8b 42 58 mov 0x58(%edx),%eax <== NOT EXECUTED the_message_queue->Inactive_messages.first = message_queue_first; 115e3c: 89 5a 68 mov %ebx,0x68(%edx) <== NOT EXECUTED message_queue_last->next = inactive_first; 115e3f: 89 08 mov %ecx,(%eax) <== NOT EXECUTED inactive_first->previous = message_queue_last; 115e41: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED message_queue_first->previous = 115e44: 8d 42 68 lea 0x68(%edx),%eax <== NOT EXECUTED 115e47: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED 115e4a: 8d 42 54 lea 0x54(%edx),%eax <== NOT EXECUTED 115e4d: 89 42 50 mov %eax,0x50(%edx) <== NOT EXECUTED 115e50: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) <== NOT EXECUTED 115e57: 8d 42 50 lea 0x50(%edx),%eax <== NOT EXECUTED 115e5a: 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; 115e5d: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED the_message_queue->number_of_pending_messages = 0; 115e60: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) <== NOT EXECUTED _ISR_Enable( level ); 115e67: 56 push %esi <== NOT EXECUTED 115e68: 9d popf <== NOT EXECUTED return count; } 115e69: 5b pop %ebx <== NOT EXECUTED 115e6a: 5e pop %esi <== NOT EXECUTED 115e6b: c9 leave <== NOT EXECUTED 115e6c: c3 ret <== NOT EXECUTED 0010fdc0 <_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 ) { 10fdc0: 55 push %ebp <== NOT EXECUTED 10fdc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fdc3: 57 push %edi <== NOT EXECUTED 10fdc4: 56 push %esi <== NOT EXECUTED 10fdc5: 53 push %ebx <== NOT EXECUTED 10fdc6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fdc9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10fdcc: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10fdcf: 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; 10fdd2: 89 7b 44 mov %edi,0x44(%ebx) <== NOT EXECUTED the_message_queue->number_of_pending_messages = 0; 10fdd5: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) <== NOT EXECUTED the_message_queue->maximum_message_size = maximum_message_size; 10fddc: 89 53 4c mov %edx,0x4c(%ebx) <== NOT EXECUTED 10fddf: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED 10fde6: 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)) { 10fded: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 10fdf0: 75 1a jne 10fe0c <_CORE_message_queue_Initialize+0x4c> <== NOT EXECUTED 10fdf2: 89 d0 mov %edx,%eax <== 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 * 10fdf4: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 10fdf7: 89 f2 mov %esi,%edx <== NOT EXECUTED 10fdf9: 0f af d7 imul %edi,%edx <== NOT EXECUTED (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 10fdfc: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10fdfe: 73 18 jae 10fe18 <_CORE_message_queue_Initialize+0x58> <== NOT EXECUTED THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 10fe00: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10fe02: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fe05: 5b pop %ebx <== NOT EXECUTED 10fe06: 5e pop %esi <== NOT EXECUTED 10fe07: 5f pop %edi <== NOT EXECUTED 10fe08: c9 leave <== NOT EXECUTED 10fe09: c3 ret <== NOT EXECUTED 10fe0a: 66 90 xchg %ax,%ax <== NOT EXECUTED * check for overflow on adding overhead to each message. */ allocated_message_size = maximum_message_size; if (allocated_message_size & (sizeof(uint32_t) - 1)) { allocated_message_size += sizeof(uint32_t); 10fe0c: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED allocated_message_size &= ~(sizeof(uint32_t) - 1); 10fe0f: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED } if (allocated_message_size < maximum_message_size) 10fe12: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10fe14: 77 ea ja 10fe00 <_CORE_message_queue_Initialize+0x40> <== NOT EXECUTED 10fe16: eb dc jmp 10fdf4 <_CORE_message_queue_Initialize+0x34> <== NOT EXECUTED return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 10fe18: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fe1b: 52 push %edx <== NOT EXECUTED 10fe1c: e8 e7 29 00 00 call 112808 <_Workspace_Allocate> <== NOT EXECUTED 10fe21: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 10fe24: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fe27: 85 c0 test %eax,%eax <== NOT EXECUTED 10fe29: 74 d5 je 10fe00 <_CORE_message_queue_Initialize+0x40> <== NOT EXECUTED /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 10fe2b: 56 push %esi <== NOT EXECUTED 10fe2c: 57 push %edi <== NOT EXECUTED 10fe2d: 50 push %eax <== NOT EXECUTED 10fe2e: 8d 43 68 lea 0x68(%ebx),%eax <== NOT EXECUTED 10fe31: 50 push %eax <== NOT EXECUTED 10fe32: e8 3d 66 01 00 call 126474 <_Chain_Initialize> <== NOT EXECUTED 10fe37: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10fe3a: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED 10fe3d: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED 10fe44: 8d 43 50 lea 0x50(%ebx),%eax <== NOT EXECUTED 10fe47: 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( 10fe4a: 6a 06 push $0x6 <== NOT EXECUTED 10fe4c: 68 80 00 00 00 push $0x80 <== NOT EXECUTED 10fe51: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10fe54: 83 38 01 cmpl $0x1,(%eax) <== NOT EXECUTED 10fe57: 0f 94 c0 sete %al <== NOT EXECUTED 10fe5a: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10fe5d: 50 push %eax <== NOT EXECUTED 10fe5e: 53 push %ebx <== NOT EXECUTED 10fe5f: e8 a4 1f 00 00 call 111e08 <_Thread_queue_Initialize> <== NOT EXECUTED 10fe64: b0 01 mov $0x1,%al <== NOT EXECUTED 10fe66: 83 c4 20 add $0x20,%esp <== NOT EXECUTED STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; } 10fe69: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fe6c: 5b pop %ebx <== NOT EXECUTED 10fe6d: 5e pop %esi <== NOT EXECUTED 10fe6e: 5f pop %edi <== NOT EXECUTED 10fe6f: c9 leave <== NOT EXECUTED 10fe70: c3 ret <== NOT EXECUTED 0010f040 <_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 ) { 10f040: 55 push %ebp <== NOT EXECUTED 10f041: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f043: 57 push %edi <== NOT EXECUTED 10f044: 56 push %esi <== NOT EXECUTED 10f045: 53 push %ebx <== NOT EXECUTED 10f046: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10f049: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10f04c: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10f04f: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED ISR_Level level; bool notify = false; the_message->priority = submit_type; 10f052: 89 47 08 mov %eax,0x8(%edi) <== NOT EXECUTED switch ( submit_type ) { 10f055: 3d 00 00 00 80 cmp $0x80000000,%eax <== NOT EXECUTED 10f05a: 0f 84 94 00 00 00 je 10f0f4 <_CORE_message_queue_Insert_message+0xb4> <== NOT EXECUTED 10f060: 3d ff ff ff 7f cmp $0x7fffffff,%eax <== NOT EXECUTED 10f065: 74 65 je 10f0cc <_CORE_message_queue_Insert_message+0x8c> <== 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; 10f067: 8b 5e 50 mov 0x50(%esi),%ebx <== 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 10f06a: 8d 56 54 lea 0x54(%esi),%edx <== NOT EXECUTED while ( !_Chain_Is_tail( the_header, the_node ) ) { 10f06d: 39 da cmp %ebx,%edx <== NOT EXECUTED 10f06f: 75 49 jne 10f0ba <_CORE_message_queue_Insert_message+0x7a> <== NOT EXECUTED 10f071: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10f074: 89 d3 mov %edx,%ebx <== NOT EXECUTED continue; } break; } _ISR_Disable( level ); 10f076: 9c pushf <== NOT EXECUTED 10f077: fa cli <== NOT EXECUTED 10f078: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10f079: 8b 56 48 mov 0x48(%esi),%edx <== NOT EXECUTED 10f07c: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10f07f: 89 46 48 mov %eax,0x48(%esi) <== NOT EXECUTED 10f082: 85 d2 test %edx,%edx <== NOT EXECUTED 10f084: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED notify = true; _Chain_Insert_unprotected( the_node->previous, &the_message->Node ); 10f088: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10f08b: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED 10f08e: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10f090: 89 38 mov %edi,(%eax) <== NOT EXECUTED 10f092: 89 17 mov %edx,(%edi) <== NOT EXECUTED 10f094: 89 7a 04 mov %edi,0x4(%edx) <== NOT EXECUTED _ISR_Enable( level ); 10f097: 51 push %ecx <== NOT EXECUTED 10f098: 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 ) 10f099: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10f09d: 74 25 je 10f0c4 <_CORE_message_queue_Insert_message+0x84> <== NOT EXECUTED 10f09f: 8b 4e 60 mov 0x60(%esi),%ecx <== NOT EXECUTED 10f0a2: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f0a4: 74 1e je 10f0c4 <_CORE_message_queue_Insert_message+0x84> <== NOT EXECUTED (*the_message_queue->notify_handler)( the_message_queue->notify_argument ); 10f0a6: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED 10f0a9: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10f0ac: 5a pop %edx <== NOT EXECUTED 10f0ad: 5b pop %ebx <== NOT EXECUTED 10f0ae: 5e pop %esi <== NOT EXECUTED 10f0af: 5f pop %edi <== NOT EXECUTED 10f0b0: 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 ); 10f0b1: ff e1 jmp *%ecx <== NOT EXECUTED 10f0b3: 90 nop <== 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 ) { the_node = the_node->next; 10f0b4: 8b 1b mov (%ebx),%ebx <== 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 ) ) { 10f0b6: 39 da cmp %ebx,%edx <== NOT EXECUTED 10f0b8: 74 ba je 10f074 <_CORE_message_queue_Insert_message+0x34> <== NOT EXECUTED this_message = (CORE_message_queue_Buffer_control *) the_node; if ( this_message->priority <= the_message->priority ) { 10f0ba: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10f0bd: 7d f5 jge 10f0b4 <_CORE_message_queue_Insert_message+0x74> <== NOT EXECUTED 10f0bf: eb b5 jmp 10f076 <_CORE_message_queue_Insert_message+0x36> <== NOT EXECUTED 10f0c1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * 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 ); } 10f0c4: 58 pop %eax <== NOT EXECUTED 10f0c5: 5b pop %ebx <== NOT EXECUTED 10f0c6: 5e pop %esi <== NOT EXECUTED 10f0c7: 5f pop %edi <== NOT EXECUTED 10f0c8: c9 leave <== NOT EXECUTED 10f0c9: c3 ret <== NOT EXECUTED 10f0ca: 66 90 xchg %ax,%ax <== NOT EXECUTED the_message->priority = submit_type; switch ( submit_type ) { case CORE_MESSAGE_QUEUE_SEND_REQUEST: _ISR_Disable( level ); 10f0cc: 9c pushf <== NOT EXECUTED 10f0cd: fa cli <== NOT EXECUTED 10f0ce: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10f0cf: 8b 56 48 mov 0x48(%esi),%edx <== NOT EXECUTED 10f0d2: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10f0d5: 89 46 48 mov %eax,0x48(%esi) <== NOT EXECUTED 10f0d8: 85 d2 test %edx,%edx <== NOT EXECUTED 10f0da: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED 10f0de: 8d 46 54 lea 0x54(%esi),%eax <== NOT EXECUTED 10f0e1: 89 07 mov %eax,(%edi) <== NOT EXECUTED 10f0e3: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED 10f0e6: 89 7e 58 mov %edi,0x58(%esi) <== NOT EXECUTED 10f0e9: 89 38 mov %edi,(%eax) <== NOT EXECUTED 10f0eb: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED notify = true; _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 10f0ee: 51 push %ecx <== NOT EXECUTED 10f0ef: 9d popf <== NOT EXECUTED 10f0f0: eb a7 jmp 10f099 <_CORE_message_queue_Insert_message+0x59> <== NOT EXECUTED 10f0f2: 66 90 xchg %ax,%ax <== NOT EXECUTED break; case CORE_MESSAGE_QUEUE_URGENT_REQUEST: _ISR_Disable( level ); 10f0f4: 9c pushf <== NOT EXECUTED 10f0f5: fa cli <== NOT EXECUTED 10f0f6: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10f0f7: 8b 56 48 mov 0x48(%esi),%edx <== NOT EXECUTED 10f0fa: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10f0fd: 89 46 48 mov %eax,0x48(%esi) <== NOT EXECUTED 10f100: 85 d2 test %edx,%edx <== NOT EXECUTED 10f102: 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 10f106: 8d 46 50 lea 0x50(%esi),%eax <== NOT EXECUTED 10f109: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED 10f10c: 8b 46 50 mov 0x50(%esi),%eax <== NOT EXECUTED 10f10f: 89 7e 50 mov %edi,0x50(%esi) <== NOT EXECUTED 10f112: 89 07 mov %eax,(%edi) <== NOT EXECUTED 10f114: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED notify = true; _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 10f117: 51 push %ecx <== NOT EXECUTED 10f118: 9d popf <== NOT EXECUTED 10f119: e9 7b ff ff ff jmp 10f099 <_CORE_message_queue_Insert_message+0x59> <== NOT EXECUTED 00115f50 <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 115f50: 55 push %ebp <== NOT EXECUTED 115f51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 115f53: 57 push %edi <== NOT EXECUTED 115f54: 56 push %esi <== NOT EXECUTED 115f55: 53 push %ebx <== NOT EXECUTED 115f56: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 115f59: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 115f5c: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 115f5f: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 115f62: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 115f65: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 115f68: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 115f6b: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 115f6e: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED 115f71: 8a 45 18 mov 0x18(%ebp),%al <== NOT EXECUTED 115f74: 88 45 eb mov %al,-0x15(%ebp) <== NOT EXECUTED ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *executing; Thread_Control *the_thread; executing = _Thread_Executing; 115f77: 8b 15 9c ca 12 00 mov 0x12ca9c,%edx <== NOT EXECUTED executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 115f7d: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED _ISR_Disable( level ); 115f84: 9c pushf <== NOT EXECUTED 115f85: fa cli <== NOT EXECUTED 115f86: 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( 115f87: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 115f8a: 8b 58 50 mov 0x50(%eax),%ebx <== NOT EXECUTED 115f8d: 83 c0 54 add $0x54,%eax <== NOT EXECUTED 115f90: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 115f92: 74 7c je 116010 <_CORE_message_queue_Seize+0xc0> <== NOT EXECUTED 115f94: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 115f96: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 115f99: 89 57 50 mov %edx,0x50(%edi) <== NOT EXECUTED 115f9c: 89 f8 mov %edi,%eax <== NOT EXECUTED 115f9e: 83 c0 50 add $0x50,%eax <== NOT EXECUTED 115fa1: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); if ( the_message != NULL ) { the_message_queue->number_of_pending_messages -= 1; 115fa4: ff 4f 48 decl 0x48(%edi) <== NOT EXECUTED _ISR_Enable( level ); 115fa7: 56 push %esi <== NOT EXECUTED 115fa8: 9d popf <== NOT EXECUTED *size_p = the_message->Contents.size; 115fa9: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 115fac: 89 01 mov %eax,(%ecx) <== NOT EXECUTED _Thread_Executing->Wait.count = the_message->priority; 115fae: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 115fb1: a1 9c ca 12 00 mov 0x12ca9c,%eax <== NOT EXECUTED 115fb6: 89 50 24 mov %edx,0x24(%eax) <== NOT EXECUTED _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size_p); 115fb9: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 115fbc: 89 45 d8 mov %eax,-0x28(%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 115fbf: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED 115fc1: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 115fc4: 89 c6 mov %eax,%esi <== NOT EXECUTED 115fc6: 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 ); 115fc8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 115fcb: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 115fce: e8 91 b4 ff ff call 111464 <_Thread_queue_Dequeue> <== NOT EXECUTED 115fd3: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !the_thread ) { 115fd5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115fd8: 85 c0 test %eax,%eax <== NOT EXECUTED 115fda: 0f 84 84 00 00 00 je 116064 <_CORE_message_queue_Seize+0x114> <== 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; 115fe0: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED 115fe3: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED the_message->Contents.size = (size_t) the_thread->Wait.option; 115fe6: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED 115fe9: 89 4b 0c mov %ecx,0xc(%ebx) <== NOT EXECUTED 115fec: 8b 72 2c mov 0x2c(%edx),%esi <== NOT EXECUTED 115fef: 8b 7d d8 mov -0x28(%ebp),%edi <== NOT EXECUTED 115ff2: 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( 115ff4: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 115ff7: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 115ffa: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 115ffd: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 116000: 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 ); } 116003: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116006: 5b pop %ebx <== NOT EXECUTED 116007: 5e pop %esi <== NOT EXECUTED 116008: 5f pop %edi <== NOT EXECUTED 116009: 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( 11600a: e9 61 fe ff ff jmp 115e70 <_CORE_message_queue_Insert_message> <== NOT EXECUTED 11600f: 90 nop <== NOT EXECUTED the_message->priority ); return; } if ( !wait ) { 116010: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) <== NOT EXECUTED 116014: 75 12 jne 116028 <_CORE_message_queue_Seize+0xd8> <== NOT EXECUTED _ISR_Enable( level ); 116016: 56 push %esi <== NOT EXECUTED 116017: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 116018: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx) <== 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 ); } 11601f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116022: 5b pop %ebx <== NOT EXECUTED 116023: 5e pop %esi <== NOT EXECUTED 116024: 5f pop %edi <== NOT EXECUTED 116025: c9 leave <== NOT EXECUTED 116026: c3 ret <== NOT EXECUTED 116027: 90 nop <== 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 116028: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11602b: c7 40 30 01 00 00 00 movl $0x1,0x30(%eax) <== 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; 116032: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED executing->Wait.id = id; 116035: 89 7a 20 mov %edi,0x20(%edx) <== NOT EXECUTED executing->Wait.return_argument_second.mutable_object = buffer; 116038: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 11603b: 89 7a 2c mov %edi,0x2c(%edx) <== NOT EXECUTED executing->Wait.return_argument = size_p; 11603e: 89 4a 28 mov %ecx,0x28(%edx) <== NOT EXECUTED /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 116041: 56 push %esi <== NOT EXECUTED 116042: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 116043: c7 45 10 f0 18 11 00 movl $0x1118f0,0x10(%ebp) <== NOT EXECUTED 11604a: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 11604d: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 116050: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 116053: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED } 116056: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116059: 5b pop %ebx <== NOT EXECUTED 11605a: 5e pop %esi <== NOT EXECUTED 11605b: 5f pop %edi <== NOT EXECUTED 11605c: 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 ); 11605d: e9 3e b5 ff ff jmp 1115a0 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 116062: 66 90 xchg %ax,%ax <== 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 116064: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 116067: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11606a: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 11606d: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 116070: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116073: 5b pop %ebx <== NOT EXECUTED 116074: 5e pop %esi <== NOT EXECUTED 116075: 5f pop %edi <== NOT EXECUTED 116076: c9 leave <== NOT EXECUTED 116077: e9 c8 9a ff ff jmp 10fb44 <_Chain_Append> <== NOT EXECUTED 0010ad84 <_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 ) { 10ad84: 55 push %ebp <== NOT EXECUTED 10ad85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad87: 57 push %edi <== NOT EXECUTED 10ad88: 56 push %esi <== NOT EXECUTED 10ad89: 53 push %ebx <== NOT EXECUTED 10ad8a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10ad8d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10ad90: 8a 45 20 mov 0x20(%ebp),%al <== NOT EXECUTED 10ad93: 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 ) { 10ad96: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10ad99: 39 53 4c cmp %edx,0x4c(%ebx) <== NOT EXECUTED 10ad9c: 72 6e jb 10ae0c <_CORE_message_queue_Submit+0x88> <== NOT EXECUTED /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { 10ad9e: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10ada1: 85 c0 test %eax,%eax <== NOT EXECUTED 10ada3: 74 77 je 10ae1c <_CORE_message_queue_Submit+0x98> <== 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 < 10ada5: 39 43 44 cmp %eax,0x44(%ebx) <== NOT EXECUTED 10ada8: 0f 87 be 00 00 00 ja 10ae6c <_CORE_message_queue_Submit+0xe8> <== 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 ) { 10adae: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10adb2: 0f 84 9c 00 00 00 je 10ae54 <_CORE_message_queue_Submit+0xd0> <== 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() ) { 10adb8: a1 98 ea 11 00 mov 0x11ea98,%eax <== NOT EXECUTED 10adbd: 85 c0 test %eax,%eax <== NOT EXECUTED 10adbf: 0f 85 97 00 00 00 jne 10ae5c <_CORE_message_queue_Submit+0xd8> <== 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; 10adc5: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED _ISR_Disable( level ); 10adca: 9c pushf <== NOT EXECUTED 10adcb: fa cli <== NOT EXECUTED 10adcc: 5a pop %edx <== 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 10adcd: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) <== NOT EXECUTED _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; 10add4: 89 58 44 mov %ebx,0x44(%eax) <== NOT EXECUTED executing->Wait.id = id; 10add7: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 10adda: 89 70 20 mov %esi,0x20(%eax) <== NOT EXECUTED executing->Wait.return_argument_second.immutable_object = buffer; 10addd: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10ade0: 89 48 2c mov %ecx,0x2c(%eax) <== NOT EXECUTED executing->Wait.option = (uint32_t) size; 10ade3: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10ade6: 89 70 30 mov %esi,0x30(%eax) <== NOT EXECUTED executing->Wait.count = submit_type; 10ade9: 8b 4d 1c mov 0x1c(%ebp),%ecx <== NOT EXECUTED 10adec: 89 48 24 mov %ecx,0x24(%eax) <== NOT EXECUTED _ISR_Enable( level ); 10adef: 52 push %edx <== NOT EXECUTED 10adf0: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 10adf1: 50 push %eax <== NOT EXECUTED 10adf2: 68 b8 ca 10 00 push $0x10cab8 <== NOT EXECUTED 10adf7: ff 75 24 pushl 0x24(%ebp) <== NOT EXECUTED 10adfa: 53 push %ebx <== NOT EXECUTED 10adfb: e8 68 19 00 00 call 10c768 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 10ae00: b8 07 00 00 00 mov $0x7,%eax <== NOT EXECUTED 10ae05: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae08: eb 07 jmp 10ae11 <_CORE_message_queue_Submit+0x8d> <== NOT EXECUTED 10ae0a: 66 90 xchg %ax,%ax <== NOT EXECUTED { ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 10ae0c: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; } 10ae11: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ae14: 5b pop %ebx <== NOT EXECUTED 10ae15: 5e pop %esi <== NOT EXECUTED 10ae16: 5f pop %edi <== NOT EXECUTED 10ae17: c9 leave <== NOT EXECUTED 10ae18: c3 ret <== NOT EXECUTED 10ae19: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 10ae1c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae1f: 53 push %ebx <== NOT EXECUTED 10ae20: e8 07 18 00 00 call 10c62c <_Thread_queue_Dequeue> <== NOT EXECUTED 10ae25: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( the_thread ) { 10ae27: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae2a: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae2c: 74 7e je 10aeac <_CORE_message_queue_Submit+0x128> <== 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 10ae2e: 8b 78 2c mov 0x2c(%eax),%edi <== NOT EXECUTED 10ae31: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10ae34: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10ae37: 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; 10ae39: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 10ae3c: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10ae3f: 89 08 mov %ecx,(%eax) <== NOT EXECUTED the_thread->Wait.count = submit_type; 10ae41: 8b 75 1c mov 0x1c(%ebp),%esi <== NOT EXECUTED 10ae44: 89 72 24 mov %esi,0x24(%edx) <== NOT EXECUTED 10ae47: 31 c0 xor %eax,%eax <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; } 10ae49: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ae4c: 5b pop %ebx <== NOT EXECUTED 10ae4d: 5e pop %esi <== NOT EXECUTED 10ae4e: 5f pop %edi <== NOT EXECUTED 10ae4f: c9 leave <== NOT EXECUTED 10ae50: c3 ret <== NOT EXECUTED 10ae51: 8d 76 00 lea 0x0(%esi),%esi <== 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 ) { 10ae54: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10ae59: eb b6 jmp 10ae11 <_CORE_message_queue_Submit+0x8d> <== NOT EXECUTED 10ae5b: 90 nop <== NOT EXECUTED _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; 10ae5c: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } 10ae61: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ae64: 5b pop %ebx <== NOT EXECUTED 10ae65: 5e pop %esi <== NOT EXECUTED 10ae66: 5f pop %edi <== NOT EXECUTED 10ae67: c9 leave <== NOT EXECUTED 10ae68: c3 ret <== NOT EXECUTED 10ae69: 8d 76 00 lea 0x0(%esi),%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. 10ae6c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae6f: 8d 43 68 lea 0x68(%ebx),%eax <== NOT EXECUTED 10ae72: 50 push %eax <== NOT EXECUTED 10ae73: e8 e4 fe ff ff call 10ad5c <_Chain_Get> <== NOT EXECUTED /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 10ae78: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae7b: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae7d: 74 dd je 10ae5c <_CORE_message_queue_Submit+0xd8> <== 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 10ae7f: 8d 78 10 lea 0x10(%eax),%edi <== NOT EXECUTED 10ae82: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10ae85: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10ae88: 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; 10ae8a: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10ae8d: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED the_message->priority = submit_type; 10ae90: 8b 4d 1c mov 0x1c(%ebp),%ecx <== NOT EXECUTED 10ae93: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED _CORE_message_queue_Insert_message( 10ae96: 52 push %edx <== NOT EXECUTED 10ae97: 51 push %ecx <== NOT EXECUTED 10ae98: 50 push %eax <== NOT EXECUTED 10ae99: 53 push %ebx <== NOT EXECUTED 10ae9a: e8 a1 41 00 00 call 10f040 <_CORE_message_queue_Insert_message> <== NOT EXECUTED 10ae9f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10aea1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aea4: e9 68 ff ff ff jmp 10ae11 <_CORE_message_queue_Submit+0x8d> <== NOT EXECUTED 10aea9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); if ( the_thread ) { 10aeac: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10aeaf: e9 f1 fe ff ff jmp 10ada5 <_CORE_message_queue_Submit+0x21> <== NOT EXECUTED 0010aeb4 <_CORE_mutex_Flush>: void _CORE_mutex_Flush( CORE_mutex_Control *the_mutex, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 10aeb4: 55 push %ebp <== NOT EXECUTED 10aeb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Thread_queue_Flush( &the_mutex->Wait_queue, remote_extract_callout, status ); } 10aeb7: c9 leave <== NOT EXECUTED CORE_mutex_Control *the_mutex, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { _Thread_queue_Flush( 10aeb8: e9 f3 1a 00 00 jmp 10c9b0 <_Thread_queue_Flush> <== NOT EXECUTED 0010aec0 <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 10aec0: 55 push %ebp <== NOT EXECUTED 10aec1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aec3: 57 push %edi <== NOT EXECUTED 10aec4: 56 push %esi <== NOT EXECUTED 10aec5: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10aec8: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10aecb: 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; 10aece: 8d 7a 40 lea 0x40(%edx),%edi <== NOT EXECUTED 10aed1: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10aed6: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10aed9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED the_mutex->lock = initial_lock; 10aedb: 89 42 50 mov %eax,0x50(%edx) <== NOT EXECUTED the_mutex->blocked_count = 0; 10aede: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx) <== NOT EXECUTED if ( initial_lock == CORE_MUTEX_LOCKED ) { 10aee5: 85 c0 test %eax,%eax <== NOT EXECUTED 10aee7: 75 33 jne 10af1c <_CORE_mutex_Initialize+0x5c> <== NOT EXECUTED the_mutex->nest_count = 1; 10aee9: c7 42 54 01 00 00 00 movl $0x1,0x54(%edx) <== NOT EXECUTED the_mutex->holder = _Thread_Executing; 10aef0: 8b 0d bc ea 11 00 mov 0x11eabc,%ecx <== NOT EXECUTED 10aef6: 89 4a 5c mov %ecx,0x5c(%edx) <== NOT EXECUTED the_mutex->holder_id = _Thread_Executing->Object.id; 10aef9: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10aefc: 89 42 60 mov %eax,0x60(%edx) <== 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 10aeff: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 10af02: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10af05: 74 05 je 10af0c <_CORE_mutex_Initialize+0x4c> <== NOT EXECUTED 10af07: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10af0a: 75 25 jne 10af31 <_CORE_mutex_Initialize+0x71> <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < 10af0c: 8b 41 14 mov 0x14(%ecx),%eax <== NOT EXECUTED 10af0f: 3b 42 4c cmp 0x4c(%edx),%eax <== NOT EXECUTED 10af12: 72 48 jb 10af5c <_CORE_mutex_Initialize+0x9c> <== 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++; 10af14: ff 41 1c incl 0x1c(%ecx) <== NOT EXECUTED 10af17: eb 18 jmp 10af31 <_CORE_mutex_Initialize+0x71> <== NOT EXECUTED 10af19: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } } else { the_mutex->nest_count = 0; 10af1c: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) <== NOT EXECUTED the_mutex->holder = NULL; 10af23: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx) <== NOT EXECUTED the_mutex->holder_id = 0; 10af2a: c7 42 60 00 00 00 00 movl $0x0,0x60(%edx) <== NOT EXECUTED } _Thread_queue_Initialize( 10af31: 6a 05 push $0x5 <== NOT EXECUTED 10af33: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 10af38: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10af3b: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10af3e: 85 c0 test %eax,%eax <== NOT EXECUTED 10af40: 0f 95 c0 setne %al <== NOT EXECUTED 10af43: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10af46: 50 push %eax <== NOT EXECUTED 10af47: 52 push %edx <== NOT EXECUTED 10af48: e8 8f 1a 00 00 call 10c9dc <_Thread_queue_Initialize> <== NOT EXECUTED 10af4d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10af4f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10af52: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10af55: 5e pop %esi <== NOT EXECUTED 10af56: 5f pop %edi <== NOT EXECUTED 10af57: c9 leave <== NOT EXECUTED 10af58: c3 ret <== NOT EXECUTED 10af59: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_mutex->holder = _Thread_Executing; the_mutex->holder_id = _Thread_Executing->Object.id; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < 10af5c: b8 06 00 00 00 mov $0x6,%eax <== NOT EXECUTED STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10af61: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10af64: 5e pop %esi <== NOT EXECUTED 10af65: 5f pop %edi <== NOT EXECUTED 10af66: c9 leave <== NOT EXECUTED 10af67: c3 ret <== NOT EXECUTED 0010afb8 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 10afb8: 55 push %ebp <== NOT EXECUTED 10afb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10afbb: 56 push %esi <== NOT EXECUTED 10afbc: 53 push %ebx <== NOT EXECUTED 10afbd: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10afc0: 8a 5d 10 mov 0x10(%ebp),%bl <== NOT EXECUTED _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10afc3: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10afc8: 85 c0 test %eax,%eax <== NOT EXECUTED 10afca: 74 04 je 10afd0 <_CORE_mutex_Seize+0x18> <== NOT EXECUTED 10afcc: 84 db test %bl,%bl <== NOT EXECUTED 10afce: 75 30 jne 10b000 <_CORE_mutex_Seize+0x48> <== NOT EXECUTED 10afd0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10afd3: 8d 45 18 lea 0x18(%ebp),%eax <== NOT EXECUTED 10afd6: 50 push %eax <== NOT EXECUTED 10afd7: 56 push %esi <== NOT EXECUTED 10afd8: e8 43 41 00 00 call 10f120 <_CORE_mutex_Seize_interrupt_trylock> <== NOT EXECUTED 10afdd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10afe0: 85 c0 test %eax,%eax <== NOT EXECUTED 10afe2: 74 14 je 10aff8 <_CORE_mutex_Seize+0x40> <== NOT EXECUTED 10afe4: 84 db test %bl,%bl <== NOT EXECUTED 10afe6: 75 30 jne 10b018 <_CORE_mutex_Seize+0x60> <== NOT EXECUTED 10afe8: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10afeb: 9d popf <== NOT EXECUTED 10afec: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED 10aff1: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) <== NOT EXECUTED } 10aff8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10affb: 5b pop %ebx <== NOT EXECUTED 10affc: 5e pop %esi <== NOT EXECUTED 10affd: c9 leave <== NOT EXECUTED 10affe: c3 ret <== NOT EXECUTED 10afff: 90 nop <== NOT EXECUTED bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10b000: 83 3d c4 eb 11 00 01 cmpl $0x1,0x11ebc4 <== NOT EXECUTED 10b007: 76 c7 jbe 10afd0 <_CORE_mutex_Seize+0x18> <== NOT EXECUTED 10b009: 53 push %ebx <== NOT EXECUTED 10b00a: 6a 13 push $0x13 <== NOT EXECUTED 10b00c: 6a 00 push $0x0 <== NOT EXECUTED 10b00e: 6a 00 push $0x0 <== NOT EXECUTED 10b010: e8 c7 04 00 00 call 10b4dc <_Internal_error_Occurred> <== NOT EXECUTED 10b015: 8d 76 00 lea 0x0(%esi),%esi <== 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 10b018: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi) <== NOT EXECUTED 10b01f: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED 10b024: 89 70 44 mov %esi,0x44(%eax) <== NOT EXECUTED 10b027: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10b02a: 89 50 20 mov %edx,0x20(%eax) <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10b02d: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10b032: 40 inc %eax <== NOT EXECUTED 10b033: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED 10b038: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10b03b: 9d popf <== NOT EXECUTED 10b03c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b03f: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10b042: 56 push %esi <== NOT EXECUTED 10b043: e8 20 ff ff ff call 10af68 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 10b048: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b04b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b04e: 5b pop %ebx <== NOT EXECUTED 10b04f: 5e pop %esi <== NOT EXECUTED 10b050: c9 leave <== NOT EXECUTED 10b051: c3 ret <== NOT EXECUTED 0010af68 <_CORE_mutex_Seize_interrupt_blocking>: void _CORE_mutex_Seize_interrupt_blocking( CORE_mutex_Control *the_mutex, Watchdog_Interval timeout ) { 10af68: 55 push %ebp <== NOT EXECUTED 10af69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10af6b: 56 push %esi <== NOT EXECUTED 10af6c: 53 push %ebx <== NOT EXECUTED 10af6d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10af70: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 10af73: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 10af78: 83 7b 48 02 cmpl $0x2,0x48(%ebx) <== NOT EXECUTED 10af7c: 74 1e je 10af9c <_CORE_mutex_Seize_interrupt_blocking+0x34> <== NOT EXECUTED FALSE ); } } the_mutex->blocked_count++; 10af7e: ff 43 58 incl 0x58(%ebx) <== NOT EXECUTED _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 10af81: 50 push %eax <== NOT EXECUTED 10af82: 68 b8 ca 10 00 push $0x10cab8 <== NOT EXECUTED 10af87: 56 push %esi <== NOT EXECUTED 10af88: 53 push %ebx <== NOT EXECUTED 10af89: e8 da 17 00 00 call 10c768 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 10af8e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10af91: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10af94: 5b pop %ebx <== NOT EXECUTED 10af95: 5e pop %esi <== NOT EXECUTED 10af96: c9 leave <== NOT EXECUTED } the_mutex->blocked_count++; _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); _Thread_Enable_dispatch(); 10af97: e9 0c 13 00 00 jmp 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED { Thread_Control *executing; executing = _Thread_Executing; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { if ( the_mutex->holder->current_priority > executing->current_priority ) { 10af9c: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED 10af9f: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10afa2: 39 42 14 cmp %eax,0x14(%edx) <== NOT EXECUTED 10afa5: 76 d7 jbe 10af7e <_CORE_mutex_Seize_interrupt_blocking+0x16> <== NOT EXECUTED _Thread_Change_priority( 10afa7: 51 push %ecx <== NOT EXECUTED 10afa8: 6a 00 push $0x0 <== NOT EXECUTED 10afaa: 50 push %eax <== NOT EXECUTED 10afab: 52 push %edx <== NOT EXECUTED 10afac: e8 1b 0e 00 00 call 10bdcc <_Thread_Change_priority> <== NOT EXECUTED 10afb1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10afb4: eb c8 jmp 10af7e <_CORE_mutex_Seize_interrupt_blocking+0x16> <== NOT EXECUTED 0010f120 <_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 ) { 10f120: 55 push %ebp <== NOT EXECUTED 10f121: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f123: 53 push %ebx <== NOT EXECUTED 10f124: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10f127: 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 ); 10f12a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f12d: 8b 18 mov (%eax),%ebx <== 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. * 10f12f: 8b 15 bc ea 11 00 mov 0x11eabc,%edx <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10f135: 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 10f13c: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED 10f13f: 85 c0 test %eax,%eax <== NOT EXECUTED 10f141: 74 2d je 10f170 <_CORE_mutex_Seize_interrupt_trylock+0x50> <== NOT EXECUTED * to be resized 10f143: c7 41 50 00 00 00 00 movl $0x0,0x50(%ecx) <== NOT EXECUTED * @param[in] size is the new size 10f14a: 89 51 5c mov %edx,0x5c(%ecx) <== NOT EXECUTED * 10f14d: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10f150: 89 41 60 mov %eax,0x60(%ecx) <== NOT EXECUTED * @return TRUE if successfully able to resize the block. 10f153: 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 10f15a: 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. 10f15d: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10f160: 74 1e je 10f180 <_CORE_mutex_Seize_interrupt_trylock+0x60> <== NOT EXECUTED 10f162: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10f165: 74 19 je 10f180 <_CORE_mutex_Seize_interrupt_trylock+0x60> <== 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. * * @param[in] the_heap is the heap to operate upon 10f167: 53 push %ebx <== NOT EXECUTED 10f168: 9d popf <== NOT EXECUTED 10f169: 31 c0 xor %eax,%eax <== NOT EXECUTED return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); } 10f16b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f16e: c9 leave <== NOT EXECUTED 10f16f: c3 ret <== 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. 10f170: 3b 51 5c cmp 0x5c(%ecx),%edx <== NOT EXECUTED 10f173: 74 3f je 10f1b4 <_CORE_mutex_Seize_interrupt_trylock+0x94> <== NOT EXECUTED Heap_Control *the_heap, Heap_Information *info ); #ifdef __cplusplus } 10f175: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10f17a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f17d: c9 leave <== NOT EXECUTED 10f17e: c3 ret <== NOT EXECUTED 10f17f: 90 nop <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10f180: 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. * 10f183: 83 79 48 03 cmpl $0x3,0x48(%ecx) <== NOT EXECUTED 10f187: 75 de jne 10f167 <_CORE_mutex_Seize_interrupt_trylock+0x47> <== NOT EXECUTED void *start_address ); /** * This routine walks the heap to verify its integrity. * 10f189: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10f18c: 39 41 4c cmp %eax,0x4c(%ecx) <== NOT EXECUTED 10f18f: 74 47 je 10f1d8 <_CORE_mutex_Seize_interrupt_trylock+0xb8> <== NOT EXECUTED * @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. */ 10f191: 72 4d jb 10f1e0 <_CORE_mutex_Seize_interrupt_trylock+0xc0> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header * @param[in] the_info pointer to a status information area 10f193: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) <== NOT EXECUTED * 10f19a: c7 41 50 01 00 00 00 movl $0x1,0x50(%ecx) <== NOT EXECUTED * @return true if successfully able to return information 10f1a1: c7 41 54 00 00 00 00 movl $0x0,0x54(%ecx) <== NOT EXECUTED */ 10f1a8: ff 4a 1c decl 0x1c(%edx) <== NOT EXECUTED bool _Protected_heap_Get_information( 10f1ab: 53 push %ebx <== NOT EXECUTED 10f1ac: 9d popf <== NOT EXECUTED 10f1ad: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f1af: eb c9 jmp 10f17a <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 10f1b1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * * @param[in] the_heap pointer to heap header. * @param[in] info pointer to the free block information. * * @return free block information filled in. */ 10f1b4: 8b 41 40 mov 0x40(%ecx),%eax <== NOT EXECUTED 10f1b7: 85 c0 test %eax,%eax <== NOT EXECUTED 10f1b9: 74 11 je 10f1cc <_CORE_mutex_Seize_interrupt_trylock+0xac> <== NOT EXECUTED 10f1bb: 48 dec %eax <== NOT EXECUTED 10f1bc: 75 b7 jne 10f175 <_CORE_mutex_Seize_interrupt_trylock+0x55> <== NOT EXECUTED bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ); #ifdef __cplusplus 10f1be: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) <== NOT EXECUTED } 10f1c5: 53 push %ebx <== NOT EXECUTED 10f1c6: 9d popf <== NOT EXECUTED 10f1c7: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f1c9: eb af jmp 10f17a <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 10f1cb: 90 nop <== NOT EXECUTED * @param[in] info pointer to the free block information. * * @return free block information filled in. */ bool _Protected_heap_Get_free_information( Heap_Control *the_heap, 10f1cc: ff 41 54 incl 0x54(%ecx) <== NOT EXECUTED Heap_Information *info 10f1cf: 53 push %ebx <== NOT EXECUTED 10f1d0: 9d popf <== NOT EXECUTED 10f1d1: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f1d3: eb a5 jmp 10f17a <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 10f1d5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /** * This routine walks the heap to verify its integrity. * * @param[in] the_heap is the heap to operate upon * @param[in] source is a user specified integer which may be used to 10f1d8: 53 push %ebx <== NOT EXECUTED 10f1d9: 9d popf <== NOT EXECUTED 10f1da: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f1dc: eb 9c jmp 10f17a <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 10f1de: 66 90 xchg %ax,%ax <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10f1e0: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10f1e5: 40 inc %eax <== NOT EXECUTED 10f1e6: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== 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, 10f1eb: 53 push %ebx <== NOT EXECUTED 10f1ec: 9d popf <== NOT EXECUTED int source, 10f1ed: 50 push %eax <== NOT EXECUTED 10f1ee: 6a 00 push $0x0 <== NOT EXECUTED 10f1f0: ff 71 4c pushl 0x4c(%ecx) <== NOT EXECUTED 10f1f3: ff 71 5c pushl 0x5c(%ecx) <== NOT EXECUTED 10f1f6: e8 d1 cb ff ff call 10bdcc <_Thread_Change_priority> <== NOT EXECUTED bool do_dump ); /** * This routine walks the heap and tots up the free and allocated 10f1fb: e8 a8 d0 ff ff call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10f200: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f202: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f205: e9 70 ff ff ff jmp 10f17a <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 0010b054 <_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 ) { 10b054: 55 push %ebp <== NOT EXECUTED 10b055: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b057: 53 push %ebx <== NOT EXECUTED 10b058: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b05b: 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; 10b05e: 8b 53 5c mov 0x5c(%ebx),%edx <== 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 ) { 10b061: 80 7b 44 00 cmpb $0x0,0x44(%ebx) <== NOT EXECUTED 10b065: 74 15 je 10b07c <_CORE_mutex_Surrender+0x28> <== NOT EXECUTED if ( !_Thread_Is_executing( holder ) ) 10b067: 3b 15 bc ea 11 00 cmp 0x11eabc,%edx <== NOT EXECUTED 10b06d: 74 0d je 10b07c <_CORE_mutex_Surrender+0x28> <== NOT EXECUTED 10b06f: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 10b074: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b077: c9 leave <== NOT EXECUTED 10b078: c3 ret <== NOT EXECUTED 10b079: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; } /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) 10b07c: 8b 43 54 mov 0x54(%ebx),%eax <== NOT EXECUTED 10b07f: 85 c0 test %eax,%eax <== NOT EXECUTED 10b081: 74 69 je 10b0ec <_CORE_mutex_Surrender+0x98> <== NOT EXECUTED return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 10b083: 48 dec %eax <== NOT EXECUTED 10b084: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED if ( the_mutex->nest_count != 0 ) { 10b087: 85 c0 test %eax,%eax <== NOT EXECUTED 10b089: 75 69 jne 10b0f4 <_CORE_mutex_Surrender+0xa0> <== 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 10b08b: 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 ) || 10b08e: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b091: 0f 84 91 00 00 00 je 10b128 <_CORE_mutex_Surrender+0xd4> <== NOT EXECUTED 10b097: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b09a: 0f 84 88 00 00 00 je 10b128 <_CORE_mutex_Surrender+0xd4> <== NOT EXECUTED } first_node = _Chain_Get_first_unprotected(&holder->lock_mutex); #endif holder->resource_count--; } the_mutex->holder = NULL; 10b0a0: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = 0; 10b0a7: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== 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 ) || 10b0ae: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b0b1: 74 55 je 10b108 <_CORE_mutex_Surrender+0xb4> <== NOT EXECUTED 10b0b3: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b0b6: 74 50 je 10b108 <_CORE_mutex_Surrender+0xb4> <== 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 ) ) ) { 10b0b8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b0bb: 53 push %ebx <== NOT EXECUTED 10b0bc: e8 6b 15 00 00 call 10c62c <_Thread_queue_Dequeue> <== NOT EXECUTED 10b0c1: 89 c2 mov %eax,%edx <== NOT EXECUTED 10b0c3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b0c6: 85 c0 test %eax,%eax <== NOT EXECUTED 10b0c8: 0f 84 8e 00 00 00 je 10b15c <_CORE_mutex_Surrender+0x108> <== NOT EXECUTED } else #endif { the_mutex->holder = the_thread; 10b0ce: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = the_thread->Object.id; 10b0d1: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10b0d4: 89 43 60 mov %eax,0x60(%ebx) <== NOT EXECUTED the_mutex->nest_count = 1; 10b0d7: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx) <== NOT EXECUTED switch ( the_mutex->Attributes.discipline ) { 10b0de: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10b0e1: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b0e4: 74 6a je 10b150 <_CORE_mutex_Surrender+0xfc> <== NOT EXECUTED 10b0e6: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b0e9: 74 45 je 10b130 <_CORE_mutex_Surrender+0xdc> <== NOT EXECUTED 10b0eb: 90 nop <== NOT EXECUTED } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 10b0ec: 31 c0 xor %eax,%eax <== NOT EXECUTED return CORE_MUTEX_STATUS_SUCCESSFUL; } 10b0ee: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b0f1: c9 leave <== NOT EXECUTED 10b0f2: c3 ret <== NOT EXECUTED 10b0f3: 90 nop <== NOT EXECUTED return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; if ( the_mutex->nest_count != 0 ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 10b0f4: 8b 43 40 mov 0x40(%ebx),%eax <== NOT EXECUTED 10b0f7: 85 c0 test %eax,%eax <== NOT EXECUTED 10b0f9: 74 f1 je 10b0ec <_CORE_mutex_Surrender+0x98> <== NOT EXECUTED 10b0fb: 48 dec %eax <== NOT EXECUTED 10b0fc: 75 8d jne 10b08b <_CORE_mutex_Surrender+0x37> <== NOT EXECUTED 10b0fe: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10b103: e9 6c ff ff ff jmp 10b074 <_CORE_mutex_Surrender+0x20> <== 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 && 10b108: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 10b10b: 85 c0 test %eax,%eax <== NOT EXECUTED 10b10d: 75 a9 jne 10b0b8 <_CORE_mutex_Surrender+0x64> <== NOT EXECUTED 10b10f: 8b 42 18 mov 0x18(%edx),%eax <== NOT EXECUTED 10b112: 3b 42 14 cmp 0x14(%edx),%eax <== NOT EXECUTED 10b115: 74 a1 je 10b0b8 <_CORE_mutex_Surrender+0x64> <== NOT EXECUTED holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 10b117: 51 push %ecx <== NOT EXECUTED 10b118: 6a 01 push $0x1 <== NOT EXECUTED 10b11a: 50 push %eax <== NOT EXECUTED 10b11b: 52 push %edx <== NOT EXECUTED 10b11c: e8 ab 0c 00 00 call 10bdcc <_Thread_Change_priority> <== NOT EXECUTED 10b121: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b124: eb 92 jmp 10b0b8 <_CORE_mutex_Surrender+0x64> <== NOT EXECUTED 10b126: 66 90 xchg %ax,%ax <== 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--; 10b128: ff 4a 1c decl 0x1c(%edx) <== NOT EXECUTED 10b12b: e9 70 ff ff ff jmp 10b0a0 <_CORE_mutex_Surrender+0x4c> <== 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++; 10b130: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED if (the_mutex->Attributes.priority_ceiling < 10b133: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 10b136: 3b 42 14 cmp 0x14(%edx),%eax <== NOT EXECUTED 10b139: 73 b1 jae 10b0ec <_CORE_mutex_Surrender+0x98> <== NOT EXECUTED the_thread->current_priority){ _Thread_Change_priority( 10b13b: 51 push %ecx <== NOT EXECUTED 10b13c: 6a 00 push $0x0 <== NOT EXECUTED 10b13e: 50 push %eax <== NOT EXECUTED 10b13f: 52 push %edx <== NOT EXECUTED 10b140: e8 87 0c 00 00 call 10bdcc <_Thread_Change_priority> <== NOT EXECUTED 10b145: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b147: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b14a: e9 25 ff ff ff jmp 10b074 <_CORE_mutex_Surrender+0x20> <== NOT EXECUTED 10b14f: 90 nop <== 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++; 10b150: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED 10b153: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b155: e9 1a ff ff ff jmp 10b074 <_CORE_mutex_Surrender+0x20> <== NOT EXECUTED 10b15a: 66 90 xchg %ax,%ax <== NOT EXECUTED } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 10b15c: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx) <== NOT EXECUTED 10b163: 31 c0 xor %eax,%eax 10b165: e9 0a ff ff ff jmp 10b074 <_CORE_mutex_Surrender+0x20> <== NOT EXECUTED 0010b16c <_CORE_semaphore_Flush>: void _CORE_semaphore_Flush( CORE_semaphore_Control *the_semaphore, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 10b16c: 55 push %ebp <== NOT EXECUTED 10b16d: 89 e5 mov %esp,%ebp <== NOT EXECUTED &the_semaphore->Wait_queue, remote_extract_callout, status ); } 10b16f: c9 leave <== NOT EXECUTED Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { _Thread_queue_Flush( 10b170: e9 3b 18 00 00 jmp 10c9b0 <_Thread_queue_Flush> <== NOT EXECUTED 0010b178 <_CORE_semaphore_Initialize>: void _CORE_semaphore_Initialize( CORE_semaphore_Control *the_semaphore, CORE_semaphore_Attributes *the_semaphore_attributes, uint32_t initial_value ) { 10b178: 55 push %ebp <== NOT EXECUTED 10b179: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b17b: 53 push %ebx <== NOT EXECUTED 10b17c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b17f: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b182: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED the_semaphore->Attributes = *the_semaphore_attributes; 10b185: 8b 1a mov (%edx),%ebx <== NOT EXECUTED 10b187: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10b18a: 89 41 44 mov %eax,0x44(%ecx) <== NOT EXECUTED 10b18d: 89 59 40 mov %ebx,0x40(%ecx) <== NOT EXECUTED the_semaphore->count = initial_value; 10b190: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b193: 89 41 48 mov %eax,0x48(%ecx) <== NOT EXECUTED _Thread_queue_Initialize( 10b196: 6a 03 push $0x3 <== NOT EXECUTED 10b198: 68 00 02 00 00 push $0x200 <== NOT EXECUTED 10b19d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b19f: 83 7a 04 01 cmpl $0x1,0x4(%edx) <== NOT EXECUTED 10b1a3: 0f 94 c0 sete %al <== NOT EXECUTED 10b1a6: 50 push %eax <== NOT EXECUTED 10b1a7: 51 push %ecx <== NOT EXECUTED 10b1a8: e8 2f 18 00 00 call 10c9dc <_Thread_queue_Initialize> <== NOT EXECUTED 10b1ad: 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 ); } 10b1b0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b1b3: c9 leave <== NOT EXECUTED 10b1b4: c3 ret <== NOT EXECUTED 0010b1b8 <_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 ) { 10b1b8: 55 push %ebp <== NOT EXECUTED 10b1b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b1bb: 53 push %ebx <== NOT EXECUTED 10b1bc: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10b1bf: 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)) ) { 10b1c2: 53 push %ebx <== NOT EXECUTED 10b1c3: e8 64 14 00 00 call 10c62c <_Thread_queue_Dequeue> <== NOT EXECUTED 10b1c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b1cb: 85 c0 test %eax,%eax <== NOT EXECUTED 10b1cd: 74 09 je 10b1d8 <_CORE_semaphore_Surrender+0x20> <== NOT EXECUTED 10b1cf: 31 c0 xor %eax,%eax <== NOT EXECUTED status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); } return status; } 10b1d1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b1d4: c9 leave <== NOT EXECUTED 10b1d5: c3 ret <== NOT EXECUTED 10b1d6: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); 10b1d8: 9c pushf <== NOT EXECUTED 10b1d9: fa cli <== NOT EXECUTED 10b1da: 5a pop %edx <== NOT EXECUTED if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10b1db: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10b1de: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 10b1e1: 72 0d jb 10b1f0 <_CORE_semaphore_Surrender+0x38> <== NOT EXECUTED 10b1e3: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); 10b1e8: 52 push %edx <== NOT EXECUTED 10b1e9: 9d popf <== NOT EXECUTED } return status; } 10b1ea: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b1ed: c9 leave <== NOT EXECUTED 10b1ee: c3 ret <== NOT EXECUTED 10b1ef: 90 nop <== NOT EXECUTED #endif } else { _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) the_semaphore->count += 1; 10b1f0: 40 inc %eax <== NOT EXECUTED 10b1f1: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 10b1f4: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b1f6: eb f0 jmp 10b1e8 <_CORE_semaphore_Surrender+0x30> <== NOT EXECUTED 0010ad38 <_Chain_Append>: void _Chain_Append( Chain_Control *the_chain, Chain_Node *node ) { 10ad38: 55 push %ebp <== NOT EXECUTED 10ad39: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad3b: 53 push %ebx <== NOT EXECUTED 10ad3c: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ad3f: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10ad42: 9c pushf <== NOT EXECUTED 10ad43: fa cli <== NOT EXECUTED 10ad44: 5b pop %ebx <== NOT EXECUTED 10ad45: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10ad48: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10ad4a: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10ad4d: 89 51 08 mov %edx,0x8(%ecx) <== NOT EXECUTED 10ad50: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10ad52: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED _Chain_Append_unprotected( the_chain, node ); _ISR_Enable( level ); 10ad55: 53 push %ebx <== NOT EXECUTED 10ad56: 9d popf <== NOT EXECUTED } 10ad57: 5b pop %ebx <== NOT EXECUTED 10ad58: c9 leave <== NOT EXECUTED 10ad59: c3 ret <== NOT EXECUTED 0010efdc <_Chain_Extract>: */ void _Chain_Extract( Chain_Node *node ) { 10efdc: 55 push %ebp <== NOT EXECUTED 10efdd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10efdf: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10efe2: 9c pushf <== NOT EXECUTED 10efe3: fa cli <== NOT EXECUTED 10efe4: 59 pop %ecx <== NOT EXECUTED 10efe5: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10efe7: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10efea: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10efed: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Chain_Extract_unprotected( node ); _ISR_Enable( level ); 10efef: 51 push %ecx <== NOT EXECUTED 10eff0: 9d popf <== NOT EXECUTED } 10eff1: c9 leave <== NOT EXECUTED 10eff2: c3 ret <== NOT EXECUTED 0010ad5c <_Chain_Get>: */ Chain_Node *_Chain_Get( Chain_Control *the_chain ) { 10ad5c: 55 push %ebp <== NOT EXECUTED 10ad5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad5f: 53 push %ebx <== NOT EXECUTED 10ad60: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Chain_Node *return_node; return_node = NULL; _ISR_Disable( level ); 10ad63: 9c pushf <== NOT EXECUTED 10ad64: fa cli <== NOT EXECUTED 10ad65: 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( 10ad66: 8b 11 mov (%ecx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( the_chain ) ) 10ad68: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10ad6b: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10ad6d: 74 11 je 10ad80 <_Chain_Get+0x24> <== NOT EXECUTED 10ad6f: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10ad71: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10ad73: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED return_node = _Chain_Get_first_unprotected( the_chain ); _ISR_Enable( level ); 10ad76: 53 push %ebx <== NOT EXECUTED 10ad77: 9d popf <== NOT EXECUTED return return_node; } 10ad78: 89 d0 mov %edx,%eax <== NOT EXECUTED 10ad7a: 5b pop %ebx <== NOT EXECUTED 10ad7b: c9 leave <== NOT EXECUTED 10ad7c: c3 ret <== NOT EXECUTED 10ad7d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ISR_Level level; Chain_Node *return_node; return_node = NULL; _ISR_Disable( level ); if ( !_Chain_Is_empty( the_chain ) ) 10ad80: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ad82: eb f2 jmp 10ad76 <_Chain_Get+0x1a> <== NOT EXECUTED 0010eff4 <_Chain_Initialize>: Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 10eff4: 55 push %ebp <== NOT EXECUTED 10eff5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10eff7: 57 push %edi <== NOT EXECUTED 10eff8: 56 push %esi <== NOT EXECUTED 10eff9: 53 push %ebx <== NOT EXECUTED 10effa: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10effd: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10f000: 8b 5d 14 mov 0x14(%ebp),%ebx <== 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 10f003: 89 f1 mov %esi,%ecx <== NOT EXECUTED Chain_Node *current; Chain_Node *next; count = number_nodes; current = _Chain_Head( the_chain ); the_chain->permanent_null = NULL; 10f005: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) <== NOT EXECUTED next = starting_address; while ( count-- ) { 10f00c: 85 c0 test %eax,%eax <== NOT EXECUTED 10f00e: 74 22 je 10f032 <_Chain_Initialize+0x3e> <== NOT EXECUTED 10f010: 8d 50 ff lea -0x1(%eax),%edx <== NOT EXECUTED 10f013: 89 d7 mov %edx,%edi <== NOT EXECUTED 10f015: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f018: eb 03 jmp 10f01d <_Chain_Initialize+0x29> <== NOT EXECUTED 10f01a: 66 90 xchg %ax,%ax <== NOT EXECUTED 10f01c: 4a dec %edx <== NOT EXECUTED current->next = next; 10f01d: 89 01 mov %eax,(%ecx) <== NOT EXECUTED next->previous = current; 10f01f: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 10f022: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10f024: 01 d8 add %ebx,%eax <== NOT EXECUTED count = number_nodes; current = _Chain_Head( the_chain ); the_chain->permanent_null = NULL; next = starting_address; while ( count-- ) { 10f026: 85 d2 test %edx,%edx <== NOT EXECUTED 10f028: 75 f2 jne 10f01c <_Chain_Initialize+0x28> <== NOT EXECUTED 10f02a: 0f af df imul %edi,%ebx <== NOT EXECUTED 10f02d: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10f030: 01 d9 add %ebx,%ecx <== NOT EXECUTED next->previous = current; current = next; next = (Chain_Node *) _Addresses_Add_offset( (void *) next, node_size ); } current->next = _Chain_Tail( the_chain ); 10f032: 8d 46 04 lea 0x4(%esi),%eax <== NOT EXECUTED 10f035: 89 01 mov %eax,(%ecx) <== NOT EXECUTED the_chain->last = current; 10f037: 89 4e 08 mov %ecx,0x8(%esi) <== NOT EXECUTED } 10f03a: 5b pop %ebx <== NOT EXECUTED 10f03b: 5e pop %esi <== NOT EXECUTED 10f03c: 5f pop %edi <== NOT EXECUTED 10f03d: c9 leave <== NOT EXECUTED 10f03e: c3 ret <== NOT EXECUTED 00126454 <_Chain_Insert>: void _Chain_Insert( Chain_Node *after_node, Chain_Node *node ) { 126454: 55 push %ebp <== NOT EXECUTED 126455: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126457: 53 push %ebx <== NOT EXECUTED 126458: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 12645b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 12645e: 9c pushf <== NOT EXECUTED 12645f: fa cli <== NOT EXECUTED 126460: 5b pop %ebx <== NOT EXECUTED 126461: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 126464: 8b 0a mov (%edx),%ecx <== NOT EXECUTED 126466: 89 02 mov %eax,(%edx) <== NOT EXECUTED 126468: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 12646a: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED _Chain_Insert_unprotected( after_node, node ); _ISR_Enable( level ); 12646d: 53 push %ebx <== NOT EXECUTED 12646e: 9d popf <== NOT EXECUTED } 12646f: 5b pop %ebx <== NOT EXECUTED 126470: c9 leave <== NOT EXECUTED 126471: c3 ret <== NOT EXECUTED 0010ef88 <_Debug_Is_enabled>: */ bool _Debug_Is_enabled( rtems_debug_control level ) { 10ef88: 55 push %ebp <== NOT EXECUTED 10ef89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ef8b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ef8e: 85 05 c0 ea 11 00 test %eax,0x11eac0 <== NOT EXECUTED 10ef94: 0f 95 c0 setne %al <== NOT EXECUTED return (_Debug_Level & level) ? true : false; } 10ef97: c9 leave <== NOT EXECUTED 10ef98: c3 ret <== NOT EXECUTED 0010ef58 <_Debug_Manager_initialization>: * * _Debug_Manager_initialization */ void _Debug_Manager_initialization( void ) { 10ef58: 55 push %ebp <== NOT EXECUTED 10ef59: 89 e5 mov %esp,%ebp <== NOT EXECUTED void rtems_debug_disable ( rtems_debug_control to_be_disabled ) { _Debug_Level &= ~to_be_disabled; 10ef5b: c7 05 c0 ea 11 00 00 movl $0x0,0x11eac0 <== NOT EXECUTED 10ef62: 00 00 00 <== NOT EXECUTED */ void _Debug_Manager_initialization( void ) { rtems_debug_disable( RTEMS_DEBUG_ALL_MASK ); } 10ef65: c9 leave <== NOT EXECUTED 10ef66: c3 ret <== NOT EXECUTED 0010ebd8 <_Dual_ported_memory_Manager_initialization>: */ void _Dual_ported_memory_Manager_initialization( uint32_t maximum_ports ) { 10ebd8: 55 push %ebp <== NOT EXECUTED 10ebd9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ebdb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ebde: 6a 04 push $0x4 <== NOT EXECUTED 10ebe0: 6a 00 push $0x0 <== NOT EXECUTED 10ebe2: 6a 1c push $0x1c <== NOT EXECUTED 10ebe4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ebe7: 6a 07 push $0x7 <== NOT EXECUTED 10ebe9: 6a 02 push $0x2 <== NOT EXECUTED 10ebeb: 68 00 ee 11 00 push $0x11ee00 <== NOT EXECUTED 10ebf0: e8 d3 ce ff ff call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10ebf5: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ebf8: c9 leave <== NOT EXECUTED 10ebf9: c3 ret <== NOT EXECUTED 0010ebfc <_Event_Manager_initialization>: * * This routine performs the initialization necessary for this manager. */ void _Event_Manager_initialization( void ) { 10ebfc: 55 push %ebp <== NOT EXECUTED 10ebfd: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10ebff: c7 05 0c ed 11 00 00 movl $0x0,0x11ed0c <== NOT EXECUTED 10ec06: 00 00 00 <== NOT EXECUTED */ #if defined(RTEMS_MULTIPROCESSING) _MPCI_Register_packet_processor( MP_PACKET_EVENT, _Event_MP_Process_packet ); #endif } 10ec09: c9 leave <== NOT EXECUTED 10ec0a: c3 ret <== NOT EXECUTED 00109d50 <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 109d50: 55 push %ebp <== NOT EXECUTED 109d51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109d53: 57 push %edi <== NOT EXECUTED 109d54: 56 push %esi <== NOT EXECUTED 109d55: 53 push %ebx <== NOT EXECUTED 109d56: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109d59: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109d5c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 109d5f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 109d62: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED 109d65: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 109d68: 89 55 e8 mov %edx,-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; 109d6b: 8b 1d bc ea 11 00 mov 0x11eabc,%ebx <== NOT EXECUTED executing->Wait.return_code = RTEMS_SUCCESSFUL; 109d71: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED api = executing->API_Extensions[ THREAD_API_RTEMS ]; 109d78: 8b bb f4 00 00 00 mov 0xf4(%ebx),%edi <== NOT EXECUTED _ISR_Disable( level ); 109d7e: 9c pushf <== NOT EXECUTED 109d7f: fa cli <== NOT EXECUTED 109d80: 8f 45 f0 popl -0x10(%ebp) <== NOT EXECUTED pending_events = api->pending_events; 109d83: 8b 17 mov (%edi),%edx <== NOT EXECUTED seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 109d85: 89 c1 mov %eax,%ecx <== NOT EXECUTED 109d87: 21 d1 and %edx,%ecx <== NOT EXECUTED 109d89: 74 14 je 109d9f <_Event_Seize+0x4f> <== NOT EXECUTED 109d8b: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 109d8d: 0f 84 91 00 00 00 je 109e24 <_Event_Seize+0xd4> <== NOT EXECUTED 109d93: f7 c6 02 00 00 00 test $0x2,%esi <== NOT EXECUTED 109d99: 0f 85 85 00 00 00 jne 109e24 <_Event_Seize+0xd4> <== NOT EXECUTED _ISR_Enable( level ); *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { 109d9f: f7 c6 01 00 00 00 test $0x1,%esi <== NOT EXECUTED 109da5: 75 65 jne 109e0c <_Event_Seize+0xbc> <== NOT EXECUTED executing->Wait.return_code = RTEMS_UNSATISFIED; *event_out = seized_events; return; } _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 109da7: c7 05 0c ed 11 00 01 movl $0x1,0x11ed0c <== NOT EXECUTED 109dae: 00 00 00 <== NOT EXECUTED executing->Wait.option = (uint32_t) option_set; 109db1: 89 73 30 mov %esi,0x30(%ebx) <== NOT EXECUTED executing->Wait.count = (uint32_t) event_in; 109db4: 89 43 24 mov %eax,0x24(%ebx) <== NOT EXECUTED executing->Wait.return_argument = event_out; 109db7: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 109dba: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 109dbd: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 109dc0: 9d popf <== NOT EXECUTED if ( ticks ) { 109dc1: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 109dc4: 85 c0 test %eax,%eax <== NOT EXECUTED 109dc6: 0f 85 80 00 00 00 jne 109e4c <_Event_Seize+0xfc> <== NOT EXECUTED NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 109dcc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109dcf: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 109dd4: 53 push %ebx <== NOT EXECUTED 109dd5: e8 82 2d 00 00 call 10cb5c <_Thread_Set_state> <== NOT EXECUTED _ISR_Disable( level ); 109dda: 9c pushf <== NOT EXECUTED 109ddb: fa cli <== NOT EXECUTED 109ddc: 5a pop %edx <== NOT EXECUTED sync_state = _Event_Sync_state; 109ddd: a1 0c ed 11 00 mov 0x11ed0c,%eax <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 109de2: c7 05 0c ed 11 00 00 movl $0x0,0x11ed0c <== NOT EXECUTED 109de9: 00 00 00 <== NOT EXECUTED if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) { 109dec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109def: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 109df2: 74 4c je 109e40 <_Event_Seize+0xf0> <== 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 ); 109df4: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED 109df7: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 109dfa: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 109dfd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109e00: 5b pop %ebx <== NOT EXECUTED 109e01: 5e pop %esi <== NOT EXECUTED 109e02: 5f pop %edi <== NOT EXECUTED 109e03: 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 ); 109e04: e9 77 1f 00 00 jmp 10bd80 <_Thread_blocking_operation_Cancel> <== NOT EXECUTED 109e09: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { _ISR_Enable( level ); 109e0c: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 109e0f: 9d popf <== NOT EXECUTED executing->Wait.return_code = RTEMS_UNSATISFIED; 109e10: c7 43 34 0d 00 00 00 movl $0xd,0x34(%ebx) <== NOT EXECUTED *event_out = seized_events; 109e17: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 109e1a: 89 0a mov %ecx,(%edx) <== NOT EXECUTED * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); } 109e1c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109e1f: 5b pop %ebx <== NOT EXECUTED 109e20: 5e pop %esi <== NOT EXECUTED 109e21: 5f pop %edi <== NOT EXECUTED 109e22: c9 leave <== NOT EXECUTED 109e23: c3 ret <== NOT EXECUTED pending_events = api->pending_events; seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && (seized_events == event_in || _Options_Is_any( option_set )) ) { api->pending_events = 109e24: 89 c8 mov %ecx,%eax <== NOT EXECUTED 109e26: f7 d0 not %eax <== NOT EXECUTED 109e28: 21 d0 and %edx,%eax <== NOT EXECUTED 109e2a: 89 07 mov %eax,(%edi) <== NOT EXECUTED _Event_sets_Clear( pending_events, seized_events ); _ISR_Enable( level ); 109e2c: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 109e2f: 9d popf <== NOT EXECUTED *event_out = seized_events; 109e30: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 109e33: 89 08 mov %ecx,(%eax) <== NOT EXECUTED * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); } 109e35: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109e38: 5b pop %ebx <== NOT EXECUTED 109e39: 5e pop %esi <== NOT EXECUTED 109e3a: 5f pop %edi <== NOT EXECUTED 109e3b: c9 leave <== NOT EXECUTED 109e3c: c3 ret <== NOT EXECUTED 109e3d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _ISR_Disable( level ); sync_state = _Event_Sync_state; _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) { _ISR_Enable( level ); 109e40: 52 push %edx <== NOT EXECUTED 109e41: 9d popf <== NOT EXECUTED * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); } 109e42: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109e45: 5b pop %ebx <== NOT EXECUTED 109e46: 5e pop %esi <== NOT EXECUTED 109e47: 5f pop %edi <== NOT EXECUTED 109e48: c9 leave <== NOT EXECUTED 109e49: c3 ret <== NOT EXECUTED 109e4a: 66 90 xchg %ax,%ax <== NOT EXECUTED executing->Wait.return_argument = event_out; _ISR_Enable( level ); if ( ticks ) { _Watchdog_Initialize( 109e4c: 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. * 109e4f: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 109e56: c7 43 64 f4 9f 10 00 movl $0x109ff4,0x64(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 109e5d: 89 43 68 mov %eax,0x68(%ebx) <== NOT EXECUTED * the heap 109e60: 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, 109e67: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 109e6a: 89 53 54 mov %edx,0x54(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 109e6d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109e70: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 109e73: 50 push %eax <== NOT EXECUTED 109e74: 68 dc ea 11 00 push $0x11eadc <== NOT EXECUTED 109e79: e8 3a 33 00 00 call 10d1b8 <_Watchdog_Insert> <== NOT EXECUTED 109e7e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109e81: e9 46 ff ff ff jmp 109dcc <_Event_Seize+0x7c> <== NOT EXECUTED 00109edc <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 109edc: 55 push %ebp <== NOT EXECUTED 109edd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109edf: 57 push %edi <== NOT EXECUTED 109ee0: 56 push %esi <== NOT EXECUTED 109ee1: 53 push %ebx <== NOT EXECUTED 109ee2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109ee5: 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 ]; 109ee8: 8b b3 f4 00 00 00 mov 0xf4(%ebx),%esi <== NOT EXECUTED option_set = (rtems_option) the_thread->Wait.option; 109eee: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 109ef1: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED _ISR_Disable( level ); 109ef4: 9c pushf <== NOT EXECUTED 109ef5: fa cli <== NOT EXECUTED 109ef6: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED pending_events = api->pending_events; 109ef9: 8b 0e mov (%esi),%ecx <== NOT EXECUTED event_condition = (rtems_event_set) the_thread->Wait.count; 109efb: 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 ) ) { 109efe: 89 d7 mov %edx,%edi <== NOT EXECUTED 109f00: 21 cf and %ecx,%edi <== NOT EXECUTED 109f02: 74 70 je 109f74 <_Event_Surrender+0x98> <== 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() && 109f04: a1 98 ea 11 00 mov 0x11ea98,%eax <== NOT EXECUTED 109f09: 85 c0 test %eax,%eax <== NOT EXECUTED 109f0b: 74 0c je 109f19 <_Event_Surrender+0x3d> <== NOT EXECUTED 109f0d: 3b 1d bc ea 11 00 cmp 0x11eabc,%ebx <== NOT EXECUTED 109f13: 0f 84 93 00 00 00 je 109fac <_Event_Surrender+0xd0> <== NOT EXECUTED } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 109f19: f6 43 11 01 testb $0x1,0x11(%ebx) <== NOT EXECUTED 109f1d: 75 0d jne 109f2c <_Event_Surrender+0x50> <== NOT EXECUTED _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 109f1f: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 109f22: 9d popf <== NOT EXECUTED } 109f23: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109f26: 5b pop %ebx <== NOT EXECUTED 109f27: 5e pop %esi <== NOT EXECUTED 109f28: 5f pop %edi <== NOT EXECUTED 109f29: c9 leave <== NOT EXECUTED 109f2a: c3 ret <== NOT EXECUTED 109f2b: 90 nop <== NOT EXECUTED /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 109f2c: 39 fa cmp %edi,%edx <== NOT EXECUTED 109f2e: 74 06 je 109f36 <_Event_Surrender+0x5a> <== NOT EXECUTED 109f30: f6 45 f0 02 testb $0x2,-0x10(%ebp) <== NOT EXECUTED 109f34: 74 e9 je 109f1f <_Event_Surrender+0x43> <== NOT EXECUTED api->pending_events = _Event_sets_Clear( pending_events, seized_events ); 109f36: 89 f8 mov %edi,%eax <== NOT EXECUTED 109f38: f7 d0 not %eax <== NOT EXECUTED 109f3a: 21 c8 and %ecx,%eax <== NOT EXECUTED 109f3c: 89 06 mov %eax,(%esi) <== NOT EXECUTED the_thread->Wait.count = 0; 109f3e: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) <== NOT EXECUTED *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109f45: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 109f48: 89 38 mov %edi,(%eax) <== NOT EXECUTED _ISR_Flash( level ); 109f4a: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 109f4d: 9d popf <== NOT EXECUTED 109f4e: fa cli <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 109f4f: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 109f53: 74 2b je 109f80 <_Event_Surrender+0xa4> <== NOT EXECUTED _ISR_Enable( level ); 109f55: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 109f58: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 109f59: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109f5c: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 109f61: 53 push %ebx <== NOT EXECUTED 109f62: e8 99 1f 00 00 call 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 109f67: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return; } } _ISR_Enable( level ); } 109f6a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109f6d: 5b pop %ebx <== NOT EXECUTED 109f6e: 5e pop %esi <== NOT EXECUTED 109f6f: 5f pop %edi <== NOT EXECUTED 109f70: c9 leave <== NOT EXECUTED 109f71: c3 ret <== NOT EXECUTED 109f72: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { _ISR_Enable( level ); 109f74: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 109f77: 9d popf <== NOT EXECUTED } return; } } _ISR_Enable( level ); } 109f78: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109f7b: 5b pop %ebx <== NOT EXECUTED 109f7c: 5e pop %esi <== NOT EXECUTED 109f7d: 5f pop %edi <== NOT EXECUTED 109f7e: c9 leave <== NOT EXECUTED 109f7f: c3 ret <== 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 */ 109f80: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 109f87: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 109f8a: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 109f8b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109f8e: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 109f91: 50 push %eax <== NOT EXECUTED 109f92: e8 51 33 00 00 call 10d2e8 <_Watchdog_Remove> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 109f97: 58 pop %eax <== NOT EXECUTED 109f98: 5a pop %edx <== NOT EXECUTED 109f99: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 109f9e: 53 push %ebx <== NOT EXECUTED 109f9f: e8 5c 1f 00 00 call 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 109fa4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109fa7: e9 77 ff ff ff jmp 109f23 <_Event_Surrender+0x47> <== 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() && 109fac: a1 0c ed 11 00 mov 0x11ed0c,%eax <== NOT EXECUTED 109fb1: 48 dec %eax <== NOT EXECUTED 109fb2: 74 0e je 109fc2 <_Event_Surrender+0xe6> <== NOT EXECUTED 109fb4: a1 0c ed 11 00 mov 0x11ed0c,%eax <== NOT EXECUTED 109fb9: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109fbc: 0f 85 57 ff ff ff jne 109f19 <_Event_Surrender+0x3d> <== 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) ) { 109fc2: 39 fa cmp %edi,%edx <== NOT EXECUTED 109fc4: 74 06 je 109fcc <_Event_Surrender+0xf0> <== NOT EXECUTED 109fc6: f6 45 f0 02 testb $0x2,-0x10(%ebp) <== NOT EXECUTED 109fca: 74 1e je 109fea <_Event_Surrender+0x10e> <== NOT EXECUTED api->pending_events = _Event_sets_Clear( pending_events,seized_events ); 109fcc: 89 f8 mov %edi,%eax <== NOT EXECUTED 109fce: f7 d0 not %eax <== NOT EXECUTED 109fd0: 21 c8 and %ecx,%eax <== NOT EXECUTED 109fd2: 89 06 mov %eax,(%esi) <== NOT EXECUTED the_thread->Wait.count = 0; 109fd4: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) <== NOT EXECUTED *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109fdb: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 109fde: 89 38 mov %edi,(%eax) <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 109fe0: c7 05 0c ed 11 00 03 movl $0x3,0x11ed0c <== NOT EXECUTED 109fe7: 00 00 00 <== NOT EXECUTED } _ISR_Enable( level ); 109fea: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 109fed: 9d popf <== NOT EXECUTED 109fee: e9 30 ff ff ff jmp 109f23 <_Event_Surrender+0x47> <== NOT EXECUTED 00109ff4 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 109ff4: 55 push %ebp <== NOT EXECUTED 109ff5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109ff7: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 109ffa: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 109ffd: 50 push %eax <== NOT EXECUTED 109ffe: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a001: e8 c6 22 00 00 call 10c2cc <_Thread_Get> <== NOT EXECUTED 10a006: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 10a008: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a00b: 8b 4d fc mov -0x4(%ebp),%ecx <== NOT EXECUTED 10a00e: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a010: 75 3e jne 10a050 <_Event_Timeout+0x5c> <== NOT EXECUTED * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ _ISR_Disable( level ); 10a012: 9c pushf <== NOT EXECUTED 10a013: fa cli <== NOT EXECUTED 10a014: 59 pop %ecx <== NOT EXECUTED if ( !the_thread->Wait.count ) { /* verify thread is waiting */ 10a015: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED 10a018: 85 c0 test %eax,%eax <== NOT EXECUTED 10a01a: 74 38 je 10a054 <_Event_Timeout+0x60> <== NOT EXECUTED _Thread_Unnest_dispatch(); _ISR_Enable( level ); return; } the_thread->Wait.count = 0; 10a01c: c7 42 24 00 00 00 00 movl $0x0,0x24(%edx) <== NOT EXECUTED if ( _Thread_Is_executing( the_thread ) ) { 10a023: 3b 15 bc ea 11 00 cmp 0x11eabc,%edx <== NOT EXECUTED 10a029: 74 39 je 10a064 <_Event_Timeout+0x70> <== NOT EXECUTED (sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; } } the_thread->Wait.return_code = RTEMS_TIMEOUT; 10a02b: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) <== NOT EXECUTED _ISR_Enable( level ); 10a032: 51 push %ecx <== NOT EXECUTED 10a033: 9d popf <== NOT EXECUTED 10a034: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a037: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10a03c: 52 push %edx <== NOT EXECUTED 10a03d: e8 be 1e 00 00 call 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 10a042: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10a047: 48 dec %eax <== NOT EXECUTED 10a048: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED 10a04d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10a050: c9 leave <== NOT EXECUTED 10a051: c3 ret <== NOT EXECUTED 10a052: 66 90 xchg %ax,%ax <== NOT EXECUTED 10a054: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10a059: 48 dec %eax <== NOT EXECUTED 10a05a: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED _ISR_Disable( level ); if ( !the_thread->Wait.count ) { /* verify thread is waiting */ _Thread_Unnest_dispatch(); _ISR_Enable( level ); 10a05f: 51 push %ecx <== NOT EXECUTED 10a060: 9d popf <== NOT EXECUTED case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10a061: c9 leave <== NOT EXECUTED 10a062: c3 ret <== NOT EXECUTED 10a063: 90 nop <== NOT EXECUTED return; } the_thread->Wait.count = 0; if ( _Thread_Is_executing( the_thread ) ) { Thread_blocking_operation_States sync = _Event_Sync_state; 10a064: a1 0c ed 11 00 mov 0x11ed0c,%eax <== NOT EXECUTED if ( (sync == THREAD_BLOCKING_OPERATION_SYNCHRONIZED) || 10a069: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10a06c: 77 bd ja 10a02b <_Event_Timeout+0x37> <== NOT EXECUTED (sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10a06e: c7 05 0c ed 11 00 02 movl $0x2,0x11ed0c <== NOT EXECUTED 10a075: 00 00 00 <== NOT EXECUTED 10a078: eb b1 jmp 10a02b <_Event_Timeout+0x37> <== NOT EXECUTED 0010aa1c <_Extension_Manager_initialization>: */ void _Extension_Manager_initialization( uint32_t maximum_extensions ) { 10aa1c: 55 push %ebp <== NOT EXECUTED 10aa1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa1f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10aa22: 6a 04 push $0x4 <== NOT EXECUTED 10aa24: 6a 00 push $0x0 <== NOT EXECUTED 10aa26: 6a 44 push $0x44 <== NOT EXECUTED 10aa28: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10aa2b: 6a 09 push $0x9 <== NOT EXECUTED 10aa2d: 6a 02 push $0x2 <== NOT EXECUTED 10aa2f: 68 60 ed 11 00 push $0x11ed60 <== NOT EXECUTED 10aa34: e8 8f 10 00 00 call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10aa39: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , false, /* true if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10aa3c: c9 leave <== NOT EXECUTED 10aa3d: c3 ret <== NOT EXECUTED 0010f260 <_Heap_Allocate>: void *_Heap_Allocate( Heap_Control *the_heap, size_t size ) { 10f260: 55 push %ebp <== NOT EXECUTED 10f261: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f263: 57 push %edi <== NOT EXECUTED 10f264: 56 push %esi <== NOT EXECUTED 10f265: 53 push %ebx <== NOT EXECUTED 10f266: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10f269: 8b 7d 08 mov 0x8(%ebp),%edi <== 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 = 10f26c: ff 77 14 pushl 0x14(%edi) <== NOT EXECUTED 10f26f: ff 77 10 pushl 0x10(%edi) <== NOT EXECUTED 10f272: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10f275: e8 aa c1 ff ff call 10b424 <_Heap_Calc_block_size> <== NOT EXECUTED _Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size); if(the_size == 0) 10f27a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f27d: 85 c0 test %eax,%eax <== NOT EXECUTED 10f27f: 74 3b je 10f2bc <_Heap_Allocate+0x5c> <== 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( 10f281: 8b 5f 08 mov 0x8(%edi),%ebx <== NOT EXECUTED return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 10f284: 39 df cmp %ebx,%edi <== NOT EXECUTED 10f286: 74 34 je 10f2bc <_Heap_Allocate+0x5c> <== 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) { 10f288: 3b 43 04 cmp 0x4(%ebx),%eax <== NOT EXECUTED 10f28b: 76 5c jbe 10f2e9 <_Heap_Allocate+0x89> <== NOT EXECUTED stats->allocs += 1; stats->searches += search_count + 1; _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; 10f28d: 31 f6 xor %esi,%esi <== NOT EXECUTED 10f28f: eb 08 jmp 10f299 <_Heap_Allocate+0x39> <== NOT EXECUTED 10f291: 8d 76 00 lea 0x0(%esi),%esi <== 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) { 10f294: 3b 43 04 cmp 0x4(%ebx),%eax <== NOT EXECUTED 10f297: 76 2f jbe 10f2c8 <_Heap_Allocate+0x68> <== 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) 10f299: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED 10f29c: 46 inc %esi <== 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; 10f29d: 39 df cmp %ebx,%edi <== NOT EXECUTED 10f29f: 75 f3 jne 10f294 <_Heap_Allocate+0x34> <== NOT EXECUTED 10f2a1: 89 75 f0 mov %esi,-0x10(%ebp) <== NOT EXECUTED 10f2a4: 31 d2 xor %edx,%edx <== NOT EXECUTED _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; } } if(stats->max_search < search_count) 10f2a6: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10f2a9: 39 47 44 cmp %eax,0x44(%edi) <== NOT EXECUTED 10f2ac: 73 03 jae 10f2b1 <_Heap_Allocate+0x51> <== NOT EXECUTED stats->max_search = search_count; 10f2ae: 89 47 44 mov %eax,0x44(%edi) <== NOT EXECUTED return ptr; } 10f2b1: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f2b3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f2b6: 5b pop %ebx <== NOT EXECUTED 10f2b7: 5e pop %esi <== NOT EXECUTED 10f2b8: 5f pop %edi <== NOT EXECUTED 10f2b9: c9 leave <== NOT EXECUTED 10f2ba: c3 ret <== NOT EXECUTED 10f2bb: 90 nop <== NOT EXECUTED break; } } if(stats->max_search < search_count) stats->max_search = search_count; 10f2bc: 31 d2 xor %edx,%edx <== NOT EXECUTED return ptr; } 10f2be: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f2c0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f2c3: 5b pop %ebx <== NOT EXECUTED 10f2c4: 5e pop %esi <== NOT EXECUTED 10f2c5: 5f pop %edi <== NOT EXECUTED 10f2c6: c9 leave <== NOT EXECUTED 10f2c7: c3 ret <== 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) { 10f2c8: 89 75 f0 mov %esi,-0x10(%ebp) <== NOT EXECUTED (void)_Heap_Block_allocate(the_heap, the_block, the_size ); 10f2cb: 52 push %edx <== NOT EXECUTED 10f2cc: 50 push %eax <== NOT EXECUTED 10f2cd: 53 push %ebx <== NOT EXECUTED 10f2ce: 57 push %edi <== NOT EXECUTED 10f2cf: e8 84 c1 ff ff call 10b458 <_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 10f2d4: 8d 53 08 lea 0x8(%ebx),%edx <== NOT EXECUTED ptr = _Heap_User_area(the_block); stats->allocs += 1; 10f2d7: ff 47 48 incl 0x48(%edi) <== NOT EXECUTED stats->searches += search_count + 1; 10f2da: 8b 47 4c mov 0x4c(%edi),%eax <== NOT EXECUTED 10f2dd: 8d 44 06 01 lea 0x1(%esi,%eax,1),%eax <== NOT EXECUTED 10f2e1: 89 47 4c mov %eax,0x4c(%edi) <== NOT EXECUTED 10f2e4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f2e7: eb bd jmp 10f2a6 <_Heap_Allocate+0x46> <== 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) { 10f2e9: 31 f6 xor %esi,%esi <== NOT EXECUTED 10f2eb: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED 10f2f2: eb d7 jmp 10f2cb <_Heap_Allocate+0x6b> <== NOT EXECUTED 0010cc1c <_Heap_Allocate_aligned>: void *_Heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ) { 10cc1c: 55 push %ebp <== NOT EXECUTED 10cc1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cc1f: 57 push %edi <== NOT EXECUTED 10cc20: 56 push %esi <== NOT EXECUTED 10cc21: 53 push %ebx <== NOT EXECUTED 10cc22: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 10cc25: 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; 10cc28: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10cc2b: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 10cc2e: 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; 10cc31: 8d 48 fc lea -0x4(%eax),%ecx <== NOT EXECUTED 10cc34: 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); 10cc37: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10cc3a: ff 77 14 pushl 0x14(%edi) <== NOT EXECUTED 10cc3d: 52 push %edx <== NOT EXECUTED 10cc3e: 50 push %eax <== NOT EXECUTED 10cc3f: e8 8c 04 00 00 call 10d0d0 <_Heap_Calc_block_size> <== NOT EXECUTED 10cc44: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED if(the_size == 0) 10cc47: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cc4a: 85 c0 test %eax,%eax <== NOT EXECUTED 10cc4c: 0f 84 1a 01 00 00 je 10cd6c <_Heap_Allocate_aligned+0x150> <== NOT EXECUTED return NULL; if(alignment == 0) 10cc52: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10cc55: 85 c0 test %eax,%eax <== NOT EXECUTED 10cc57: 0f 84 03 01 00 00 je 10cd60 <_Heap_Allocate_aligned+0x144> <== NOT EXECUTED ) { return ( the_thread == _Thread_Heir ); } /** 10cc5d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cc60: 8b 48 08 mov 0x8(%eax),%ecx <== 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; 10cc63: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10cc65: 0f 84 01 01 00 00 je 10cd6c <_Heap_Allocate_aligned+0x150> <== NOT EXECUTED 10cc6b: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED 10cc72: eb 17 jmp 10cc8b <_Heap_Allocate_aligned+0x6f> <== 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) { 10cc74: 89 f2 mov %esi,%edx <== NOT EXECUTED aligned_user_addr = 0; } } } if(aligned_user_addr) { 10cc76: 85 ff test %edi,%edi <== NOT EXECUTED 10cc78: 75 7a jne 10ccf4 <_Heap_Allocate_aligned+0xd8> <== NOT EXECUTED 10cc7a: 66 90 xchg %ax,%ax <== 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) 10cc7c: 8b 49 08 mov 0x8(%ecx),%ecx <== NOT EXECUTED 10cc7f: ff 45 f0 incl -0x10(%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; 10cc82: 39 4d 08 cmp %ecx,0x8(%ebp) <== NOT EXECUTED 10cc85: 0f 84 ed 00 00 00 je 10cd78 <_Heap_Allocate_aligned+0x15c> <== NOT EXECUTED 10cc8b: 8b 59 04 mov 0x4(%ecx),%ebx <== NOT EXECUTED 10cc8e: 83 e3 fe and $0xfffffffe,%ebx <== 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. */ 10cc91: 39 5d e4 cmp %ebx,-0x1c(%ebp) <== NOT EXECUTED 10cc94: 77 e6 ja 10cc7c <_Heap_Allocate_aligned+0x60> <== 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)); 10cc96: 8d 71 08 lea 0x8(%ecx),%esi <== 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; 10cc99: 8d 14 19 lea (%ecx,%ebx,1),%edx <== NOT EXECUTED 10cc9c: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED aligned_user_addr = block_end - end_to_user_offs; 10cc9f: 89 d7 mov %edx,%edi <== NOT EXECUTED 10cca1: 2b 7d e0 sub -0x20(%ebp),%edi <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Dispatch_initialization( void ) { _Thread_Dispatch_disable_level = 1; } 10cca4: 89 f8 mov %edi,%eax <== NOT EXECUTED 10cca6: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cca8: f7 75 10 divl 0x10(%ebp) <== NOT EXECUTED 10ccab: 29 d7 sub %edx,%edi <== NOT EXECUTED 10ccad: 89 f8 mov %edi,%eax <== NOT EXECUTED 10ccaf: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ccb1: f7 75 dc divl -0x24(%ebp) <== NOT EXECUTED 10ccb4: 89 f8 mov %edi,%eax <== NOT EXECUTED 10ccb6: 29 d0 sub %edx,%eax <== NOT EXECUTED 10ccb8: 89 c2 mov %eax,%edx <== 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) { 10ccba: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10ccbc: 77 be ja 10cc7c <_Heap_Allocate_aligned+0x60> <== 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) { 10ccbe: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ccc1: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10ccc4: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 10ccc7: 89 d0 mov %edx,%eax <== NOT EXECUTED 10ccc9: 29 f0 sub %esi,%eax <== NOT EXECUTED 10cccb: 3b 45 ec cmp -0x14(%ebp),%eax <== NOT EXECUTED 10ccce: 73 a6 jae 10cc76 <_Heap_Allocate_aligned+0x5a> <== 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) { 10ccd0: 89 f8 mov %edi,%eax <== NOT EXECUTED 10ccd2: 29 f0 sub %esi,%eax <== NOT EXECUTED 10ccd4: 39 45 dc cmp %eax,-0x24(%ebp) <== NOT EXECUTED 10ccd7: 77 9b ja 10cc74 <_Heap_Allocate_aligned+0x58> <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); } /** 10ccd9: 89 f0 mov %esi,%eax <== NOT EXECUTED 10ccdb: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ccdd: f7 75 10 divl 0x10(%ebp) <== NOT EXECUTED * This function returns TRUE if dispatching is disabled, and FALSE 10cce0: 85 d2 test %edx,%edx <== NOT EXECUTED 10cce2: 75 6c jne 10cd50 <_Heap_Allocate_aligned+0x134> <== NOT EXECUTED 10cce4: 89 f0 mov %esi,%eax <== 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) { 10cce6: 39 55 dc cmp %edx,-0x24(%ebp) <== NOT EXECUTED 10cce9: 76 91 jbe 10cc7c <_Heap_Allocate_aligned+0x60> <== NOT EXECUTED 10cceb: 89 f2 mov %esi,%edx <== NOT EXECUTED 10cced: 89 c7 mov %eax,%edi <== NOT EXECUTED aligned_user_addr = 0; } } } if(aligned_user_addr) { 10ccef: 85 ff test %edi,%edi <== NOT EXECUTED 10ccf1: 74 89 je 10cc7c <_Heap_Allocate_aligned+0x60> <== NOT EXECUTED 10ccf3: 90 nop <== 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; 10ccf4: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 10ccf7: 83 c6 08 add $0x8,%esi <== NOT EXECUTED 10ccfa: 29 d6 sub %edx,%esi <== 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; 10ccfc: 89 da mov %ebx,%edx <== NOT EXECUTED 10ccfe: 29 f2 sub %esi,%edx <== 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) { 10cd00: 3b 55 ec cmp -0x14(%ebp),%edx <== NOT EXECUTED 10cd03: 0f 82 87 00 00 00 jb 10cd90 <_Heap_Allocate_aligned+0x174> <== 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; 10cd09: 89 d0 mov %edx,%eax <== NOT EXECUTED 10cd0b: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10cd0e: 89 41 04 mov %eax,0x4(%ecx) <== 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 ); 10cd11: 8d 04 11 lea (%ecx,%edx,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 10cd14: 89 c1 mov %eax,%ecx <== NOT EXECUTED the_block = _Heap_Block_at(the_block, the_rest); the_block->prev_size = the_rest; 10cd16: 89 10 mov %edx,(%eax) <== NOT EXECUTED the_block->size = alloc_size; 10cd18: 89 70 04 mov %esi,0x4(%eax) <== NOT EXECUTED _Heap_Block_remove(the_block); alloc_size = block_size; stats->free_blocks -= 1; } /* Mark the block as used (in the next block). */ _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED; 10cd1b: 83 4c 31 04 01 orl $0x1,0x4(%ecx,%esi,1) <== NOT EXECUTED /* Update statistics */ stats->free_size -= alloc_size; 10cd20: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10cd23: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10cd26: 29 f0 sub %esi,%eax <== NOT EXECUTED 10cd28: 89 42 30 mov %eax,0x30(%edx) <== NOT EXECUTED if(stats->min_free_size > stats->free_size) 10cd2b: 3b 42 34 cmp 0x34(%edx),%eax <== NOT EXECUTED 10cd2e: 73 03 jae 10cd33 <_Heap_Allocate_aligned+0x117> <== NOT EXECUTED stats->min_free_size = stats->free_size; 10cd30: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED stats->used_blocks += 1; 10cd33: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10cd36: ff 41 40 incl 0x40(%ecx) <== 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; 10cd39: 8b 41 4c mov 0x4c(%ecx),%eax <== NOT EXECUTED 10cd3c: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10cd3f: 8d 44 02 01 lea 0x1(%edx,%eax,1),%eax <== NOT EXECUTED 10cd43: 89 41 4c mov %eax,0x4c(%ecx) <== NOT EXECUTED stats->allocs += 1; 10cd46: ff 41 48 incl 0x48(%ecx) <== NOT EXECUTED check_result(the_heap, the_block, user_addr, aligned_user_addr, size); user_ptr = (void*)aligned_user_addr; 10cd49: 89 f8 mov %edi,%eax <== NOT EXECUTED 10cd4b: eb 2d jmp 10cd7a <_Heap_Allocate_aligned+0x15e> <== NOT EXECUTED 10cd4d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { return ( _Thread_Dispatch_disable_level == 0 ); } /** * This function returns TRUE if dispatching is disabled, and FALSE 10cd50: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10cd53: 8d 04 3e lea (%esi,%edi,1),%eax <== NOT EXECUTED 10cd56: 29 d0 sub %edx,%eax <== NOT EXECUTED 10cd58: 89 c2 mov %eax,%edx <== NOT EXECUTED 10cd5a: 29 f2 sub %esi,%edx <== NOT EXECUTED 10cd5c: eb 88 jmp 10cce6 <_Heap_Allocate_aligned+0xca> <== NOT EXECUTED 10cd5e: 66 90 xchg %ax,%ax <== NOT EXECUTED _Heap_Calc_block_size(size, page_size, the_heap->min_block_size); if(the_size == 0) return NULL; if(alignment == 0) 10cd60: c7 45 10 04 00 00 00 movl $0x4,0x10(%ebp) <== NOT EXECUTED 10cd67: e9 f1 fe ff ff jmp 10cc5d <_Heap_Allocate_aligned+0x41> <== NOT EXECUTED } } } if(stats->max_search < search_count) stats->max_search = search_count; 10cd6c: 31 c0 xor %eax,%eax <== NOT EXECUTED return user_ptr; } 10cd6e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cd71: 5b pop %ebx <== NOT EXECUTED 10cd72: 5e pop %esi <== NOT EXECUTED 10cd73: 5f pop %edi <== NOT EXECUTED 10cd74: c9 leave <== NOT EXECUTED 10cd75: c3 ret <== NOT EXECUTED 10cd76: 66 90 xchg %ax,%ax <== 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; 10cd78: 31 c0 xor %eax,%eax <== NOT EXECUTED } } } } if(stats->max_search < search_count) 10cd7a: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10cd7d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10cd80: 39 4f 44 cmp %ecx,0x44(%edi) <== NOT EXECUTED 10cd83: 73 e9 jae 10cd6e <_Heap_Allocate_aligned+0x152> <== NOT EXECUTED stats->max_search = search_count; 10cd85: 89 4f 44 mov %ecx,0x44(%edi) <== NOT EXECUTED return user_ptr; } 10cd88: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cd8b: 5b pop %ebx <== NOT EXECUTED 10cd8c: 5e pop %esi <== NOT EXECUTED 10cd8d: 5f pop %edi <== NOT EXECUTED 10cd8e: c9 leave <== NOT EXECUTED 10cd8f: c3 ret <== 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 ) { 10cd90: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) 10cd93: 8b 41 0c mov 0xc(%ecx),%eax <== NOT EXECUTED if ( _Thread_Executing->fp_context != NULL ) 10cd96: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED _Context_Restore_fp( &_Thread_Executing->fp_context ); 10cd99: 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; 10cd9c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cd9f: ff 48 38 decl 0x38(%eax) <== NOT EXECUTED 10cda2: 89 de mov %ebx,%esi <== NOT EXECUTED 10cda4: e9 72 ff ff ff jmp 10cd1b <_Heap_Allocate_aligned+0xff> <== NOT EXECUTED 0010b458 <_Heap_Block_allocate>: uint32_t _Heap_Block_allocate( Heap_Control* the_heap, Heap_Block* the_block, uint32_t alloc_size ) { 10b458: 55 push %ebp <== NOT EXECUTED 10b459: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b45b: 57 push %edi <== NOT EXECUTED 10b45c: 56 push %esi <== NOT EXECUTED 10b45d: 53 push %ebx <== NOT EXECUTED 10b45e: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10b461: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10b464: 8b 4e 04 mov 0x4(%esi),%ecx <== NOT EXECUTED 10b467: 83 e1 fe and $0xfffffffe,%ecx <== 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; 10b46a: 89 cb mov %ecx,%ebx <== NOT EXECUTED 10b46c: 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) { 10b46e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b471: 3b 58 14 cmp 0x14(%eax),%ebx <== NOT EXECUTED 10b474: 72 4a jb 10b4c0 <_Heap_Block_allocate+0x68> <== NOT EXECUTED 10b476: 8d 14 3e lea (%esi,%edi,1),%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 */ 10b479: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED bool _Protected_heap_Get_block_size( 10b47c: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size 10b47f: 89 4a 08 mov %ecx,0x8(%edx) <== NOT EXECUTED ); 10b482: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED 10b485: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED 10b488: 89 51 0c mov %edx,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; 10b48b: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b48d: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10b490: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED next_block->size = the_rest | HEAP_PREV_USED; 10b493: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b495: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10b498: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED _Heap_Block_at(next_block, the_rest)->prev_size = the_rest; 10b49b: 89 1c 1a mov %ebx,(%edx,%ebx,1) <== NOT EXECUTED alloc_size = block_size; _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED; stats->free_blocks -= 1; } /* Update statistics */ stats->free_size -= alloc_size; 10b49e: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b4a1: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10b4a4: 29 f8 sub %edi,%eax <== NOT EXECUTED 10b4a6: 89 42 30 mov %eax,0x30(%edx) <== NOT EXECUTED if(stats->min_free_size > stats->free_size) 10b4a9: 3b 42 34 cmp 0x34(%edx),%eax <== NOT EXECUTED 10b4ac: 73 03 jae 10b4b1 <_Heap_Block_allocate+0x59> <== NOT EXECUTED stats->min_free_size = stats->free_size; 10b4ae: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED stats->used_blocks += 1; 10b4b1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b4b4: ff 40 40 incl 0x40(%eax) <== NOT EXECUTED return alloc_size; } 10b4b7: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b4b9: 5b pop %ebx <== NOT EXECUTED 10b4ba: 5e pop %esi <== NOT EXECUTED 10b4bb: 5f pop %edi <== NOT EXECUTED 10b4bc: c9 leave <== NOT EXECUTED 10b4bd: c3 ret <== NOT EXECUTED 10b4be: 66 90 xchg %ax,%ax <== 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 10b4c0: 8b 56 08 mov 0x8(%esi),%edx <== NOT EXECUTED * @param[in] size is the amount of memory to allocate in bytes 10b4c3: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED * @param[in] alignment the required alignment 10b4c6: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10b4c9: 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; _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED; 10b4cc: 83 4c 0e 04 01 orl $0x1,0x4(%esi,%ecx,1) <== NOT EXECUTED stats->free_blocks -= 1; 10b4d1: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b4d4: ff 4a 38 decl 0x38(%edx) <== NOT EXECUTED 10b4d7: 89 cf mov %ecx,%edi <== NOT EXECUTED 10b4d9: eb c3 jmp 10b49e <_Heap_Block_allocate+0x46> <== NOT EXECUTED 0010b424 <_Heap_Calc_block_size>: */ size_t _Heap_Calc_block_size( size_t size, uint32_t page_size, uint32_t min_size) { 10b424: 55 push %ebp <== NOT EXECUTED 10b425: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b427: 53 push %ebx <== NOT EXECUTED 10b428: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b42b: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED uint32_t block_size = size + HEAP_BLOCK_USED_OVERHEAD; 10b42e: 8d 59 04 lea 0x4(%ecx),%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 10b431: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b433: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b435: f7 75 0c divl 0xc(%ebp) <== NOT EXECUTED */ 10b438: 85 d2 test %edx,%edx <== NOT EXECUTED 10b43a: 74 05 je 10b441 <_Heap_Calc_block_size+0x1d> <== NOT EXECUTED 10b43c: 03 5d 0c add 0xc(%ebp),%ebx <== NOT EXECUTED 10b43f: 29 d3 sub %edx,%ebx <== NOT EXECUTED 10b441: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b443: 3b 5d 10 cmp 0x10(%ebp),%ebx <== NOT EXECUTED 10b446: 73 03 jae 10b44b <_Heap_Calc_block_size+0x27> <== NOT EXECUTED 10b448: 8b 45 10 mov 0x10(%ebp),%eax <== 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; 10b44b: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10b44d: 72 02 jb 10b451 <_Heap_Calc_block_size+0x2d> <== NOT EXECUTED 10b44f: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10b451: 5a pop %edx <== NOT EXECUTED 10b452: 5b pop %ebx <== NOT EXECUTED 10b453: c9 leave <== NOT EXECUTED 10b454: c3 ret <== NOT EXECUTED 001113f8 <_Heap_Extend>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t *amount_extended ) { 1113f8: 55 push %ebp <== NOT EXECUTED 1113f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1113fb: 56 push %esi <== NOT EXECUTED 1113fc: 53 push %ebx <== NOT EXECUTED 1113fd: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 111400: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 111403: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED * 5. non-contiguous higher address (NOT SUPPORTED) * * As noted, this code only supports (4). */ if ( starting_address >= the_heap->begin && /* case 3 */ 111406: 39 41 18 cmp %eax,0x18(%ecx) <== NOT EXECUTED 111409: 76 15 jbe 111420 <_Heap_Extend+0x28> <== NOT EXECUTED 11140b: 8b 51 1c mov 0x1c(%ecx),%edx <== NOT EXECUTED starting_address < the_heap->end ) return HEAP_EXTEND_ERROR; if ( starting_address != the_heap->end ) 11140e: 39 d0 cmp %edx,%eax <== NOT EXECUTED 111410: 74 22 je 111434 <_Heap_Extend+0x3c> <== NOT EXECUTED 111412: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED stats->frees -= 1; /* Don't count subsequent call as actual free() */ _Heap_Free( the_heap, _Heap_User_area( old_final ) ); return HEAP_EXTEND_SUCCESSFUL; } 111417: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11141a: 5b pop %ebx <== NOT EXECUTED 11141b: 5e pop %esi <== NOT EXECUTED 11141c: c9 leave <== NOT EXECUTED 11141d: c3 ret <== NOT EXECUTED 11141e: 66 90 xchg %ax,%ax <== NOT EXECUTED * 5. non-contiguous higher address (NOT SUPPORTED) * * As noted, this code only supports (4). */ if ( starting_address >= the_heap->begin && /* case 3 */ 111420: 8b 51 1c mov 0x1c(%ecx),%edx <== NOT EXECUTED 111423: 39 d0 cmp %edx,%eax <== NOT EXECUTED 111425: 73 e7 jae 11140e <_Heap_Extend+0x16> <== NOT EXECUTED 111427: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED stats->frees -= 1; /* Don't count subsequent call as actual free() */ _Heap_Free( the_heap, _Heap_User_area( old_final ) ); return HEAP_EXTEND_SUCCESSFUL; } 11142c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11142f: 5b pop %ebx <== NOT EXECUTED 111430: 5e pop %esi <== NOT EXECUTED 111431: c9 leave <== NOT EXECUTED 111432: c3 ret <== NOT EXECUTED 111433: 90 nop <== 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; 111434: 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 ); 111437: 03 45 10 add 0x10(%ebp),%eax <== NOT EXECUTED the_heap->end = _Addresses_Add_offset( the_heap->end, size ); 11143a: 89 41 1c mov %eax,0x1c(%ecx) <== NOT EXECUTED the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD; 11143d: 29 d8 sub %ebx,%eax <== NOT EXECUTED 11143f: 8d 70 f8 lea -0x8(%eax),%esi <== 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) || \ 111442: 89 f0 mov %esi,%eax <== NOT EXECUTED 111444: 31 d2 xor %edx,%edx <== NOT EXECUTED 111446: f7 71 10 divl 0x10(%ecx) <== NOT EXECUTED 111449: 29 d6 sub %edx,%esi <== NOT EXECUTED 11144b: 89 f2 mov %esi,%edx <== NOT EXECUTED _Heap_Align_down( &the_size, the_heap->page_size ); *amount_extended = size; 11144d: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 111450: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 111453: 89 06 mov %eax,(%esi) <== NOT EXECUTED if( the_size < the_heap->min_block_size ) 111455: 39 51 14 cmp %edx,0x14(%ecx) <== NOT EXECUTED 111458: 76 06 jbe 111460 <_Heap_Extend+0x68> <== NOT EXECUTED 11145a: 31 c0 xor %eax,%eax <== NOT EXECUTED 11145c: eb b9 jmp 111417 <_Heap_Extend+0x1f> <== NOT EXECUTED 11145e: 66 90 xchg %ax,%ax <== NOT EXECUTED return HEAP_EXTEND_SUCCESSFUL; old_final->size = the_size | (old_final->size & HEAP_PREV_USED); 111460: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 111463: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 111466: 09 d0 or %edx,%eax <== NOT EXECUTED 111468: 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 11146b: 8d 04 13 lea (%ebx,%edx,1),%eax <== NOT EXECUTED new_final = _Heap_Block_at( old_final, the_size ); new_final->size = HEAP_PREV_USED; 11146e: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) <== NOT EXECUTED the_heap->final = new_final; 111475: 89 41 24 mov %eax,0x24(%ecx) <== NOT EXECUTED stats->size += size; 111478: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 11147b: 01 51 2c add %edx,0x2c(%ecx) <== NOT EXECUTED stats->used_blocks += 1; 11147e: ff 41 40 incl 0x40(%ecx) <== NOT EXECUTED stats->frees -= 1; /* Don't count subsequent call as actual free() */ 111481: ff 49 50 decl 0x50(%ecx) <== NOT EXECUTED _Heap_Free( the_heap, _Heap_User_area( old_final ) ); 111484: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111487: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 11148a: 50 push %eax <== NOT EXECUTED 11148b: 51 push %ecx <== NOT EXECUTED 11148c: e8 af b9 ff ff call 10ce40 <_Heap_Free> <== NOT EXECUTED 111491: 31 c0 xor %eax,%eax <== NOT EXECUTED 111493: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111496: e9 7c ff ff ff jmp 111417 <_Heap_Extend+0x1f> <== NOT EXECUTED 0010f2f4 <_Heap_Free>: bool _Heap_Free( Heap_Control *the_heap, void *starting_address ) { 10f2f4: 55 push %ebp <== NOT EXECUTED 10f2f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f2f7: 57 push %edi <== NOT EXECUTED 10f2f8: 56 push %esi <== NOT EXECUTED 10f2f9: 53 push %ebx <== NOT EXECUTED 10f2fa: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10f2fd: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10f300: 8b 45 0c mov 0xc(%ebp),%eax <== 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( 10f303: 8b 77 24 mov 0x24(%edi),%esi <== NOT EXECUTED 10f306: 8b 4f 20 mov 0x20(%edi),%ecx <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10f309: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10f30b: 77 04 ja 10f311 <_Heap_Free+0x1d> <== NOT EXECUTED 10f30d: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10f30f: 73 0b jae 10f31c <_Heap_Free+0x28> <== NOT EXECUTED stats->used_blocks -= 1; stats->free_size += the_size; stats->frees += 1; return( TRUE ); 10f311: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10f313: 83 c4 18 add $0x18,%esp <== NOT EXECUTED 10f316: 5b pop %ebx <== NOT EXECUTED 10f317: 5e pop %esi <== NOT EXECUTED 10f318: 5f pop %edi <== NOT EXECUTED 10f319: c9 leave <== NOT EXECUTED 10f31a: c3 ret <== NOT EXECUTED 10f31b: 90 nop <== NOT EXECUTED 10f31c: 8d 58 f8 lea -0x8(%eax),%ebx <== NOT EXECUTED 10f31f: 31 d2 xor %edx,%edx <== NOT EXECUTED 10f321: f7 77 10 divl 0x10(%edi) <== NOT EXECUTED 10f324: 29 d3 sub %edx,%ebx <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10f326: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 10f328: 77 e7 ja 10f311 <_Heap_Free+0x1d> <== NOT EXECUTED 10f32a: 39 de cmp %ebx,%esi <== NOT EXECUTED 10f32c: 72 e3 jb 10f311 <_Heap_Free+0x1d> <== NOT EXECUTED 10f32e: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10f331: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED 10f334: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 10f337: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 10f33a: 01 d8 add %ebx,%eax <== NOT EXECUTED 10f33c: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10f33f: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10f341: 77 ce ja 10f311 <_Heap_Free+0x1d> <== NOT EXECUTED 10f343: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10f345: 72 ca jb 10f311 <_Heap_Free+0x1d> <== NOT EXECUTED 10f347: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 10f34a: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED if ( !_Heap_Is_block_in( the_heap, next_block ) ) { _HAssert( FALSE ); return( FALSE ); } if ( !_Heap_Is_prev_used( next_block ) ) { 10f34d: f6 c2 01 test $0x1,%dl <== NOT EXECUTED 10f350: 74 bf je 10f311 <_Heap_Free+0x1d> <== NOT EXECUTED 10f352: 83 e2 fe and $0xfffffffe,%edx <== NOT EXECUTED 10f355: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED _HAssert( FALSE ); return( FALSE ); } next_size = _Heap_Block_size( next_block ); next_is_free = next_block < the_heap->final && 10f358: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10f35a: 76 74 jbe 10f3d0 <_Heap_Free+0xdc> <== NOT EXECUTED 10f35c: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10f35f: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10f362: 8b 44 02 04 mov 0x4(%edx,%eax,1),%eax <== NOT EXECUTED 10f366: 83 f0 01 xor $0x1,%eax <== NOT EXECUTED 10f369: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10f36c: 8a 45 e0 mov -0x20(%ebp),%al <== NOT EXECUTED 10f36f: 83 e0 01 and $0x1,%eax <== NOT EXECUTED !_Heap_Is_prev_used(_Heap_Block_at(next_block, next_size)); if ( !_Heap_Is_prev_used( the_block ) ) { 10f372: f6 45 dc 01 testb $0x1,-0x24(%ebp) <== NOT EXECUTED 10f376: 75 5c jne 10f3d4 <_Heap_Free+0xe0> <== NOT EXECUTED uint32_t const prev_size = the_block->prev_size; 10f378: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10f37a: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 10f37d: 29 d3 sub %edx,%ebx <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10f37f: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 10f381: 77 8e ja 10f311 <_Heap_Free+0x1d> <== NOT EXECUTED 10f383: 39 de cmp %ebx,%esi <== NOT EXECUTED 10f385: 72 8a jb 10f311 <_Heap_Free+0x1d> <== 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) ) { 10f387: f6 43 04 01 testb $0x1,0x4(%ebx) <== NOT EXECUTED 10f38b: 74 84 je 10f311 <_Heap_Free+0x1d> <== NOT EXECUTED _HAssert( FALSE ); return( FALSE ); } if ( next_is_free ) { /* coalesce both */ 10f38d: 84 c0 test %al,%al <== NOT EXECUTED 10f38f: 0f 84 a0 00 00 00 je 10f435 <_Heap_Free+0x141> <== NOT EXECUTED uint32_t const size = the_size + prev_size + next_size; 10f395: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10f398: 03 55 ec add -0x14(%ebp),%edx <== NOT EXECUTED 10f39b: 03 55 f0 add -0x10(%ebp),%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 10f39e: 8b 75 e4 mov -0x1c(%ebp),%esi <== NOT EXECUTED 10f3a1: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED * @param[in] size is the amount of memory to allocate in bytes 10f3a4: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED * @param[in] alignment the required alignment 10f3a7: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10f3aa: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED _Heap_Block_remove( next_block ); stats->free_blocks -= 1; 10f3ad: ff 4f 38 decl 0x38(%edi) <== NOT EXECUTED prev_block->size = size | HEAP_PREV_USED; 10f3b0: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f3b2: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10f3b5: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block = _Heap_Block_at( prev_block, size ); _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; 10f3b8: 89 14 13 mov %edx,(%ebx,%edx,1) <== NOT EXECUTED 10f3bb: 90 nop <== NOT EXECUTED stats->free_blocks += 1; if ( stats->max_free_blocks < stats->free_blocks ) stats->max_free_blocks = stats->free_blocks; } stats->used_blocks -= 1; 10f3bc: ff 4f 40 decl 0x40(%edi) <== NOT EXECUTED stats->free_size += the_size; 10f3bf: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 10f3c2: 01 77 30 add %esi,0x30(%edi) <== NOT EXECUTED stats->frees += 1; 10f3c5: ff 47 50 incl 0x50(%edi) <== NOT EXECUTED 10f3c8: b0 01 mov $0x1,%al <== NOT EXECUTED 10f3ca: e9 44 ff ff ff jmp 10f313 <_Heap_Free+0x1f> <== NOT EXECUTED 10f3cf: 90 nop <== NOT EXECUTED _HAssert( FALSE ); return( FALSE ); } next_size = _Heap_Block_size( next_block ); next_is_free = next_block < the_heap->final && 10f3d0: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f3d2: eb 9e jmp 10f372 <_Heap_Free+0x7e> <== NOT EXECUTED prev_block->size = size | HEAP_PREV_USED; next_block->size &= ~HEAP_PREV_USED; next_block->prev_size = size; } } else if ( next_is_free ) { /* coalesce next */ 10f3d4: 84 c0 test %al,%al <== NOT EXECUTED 10f3d6: 74 28 je 10f400 <_Heap_Free+0x10c> <== NOT EXECUTED uint32_t const size = the_size + next_size; 10f3d8: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10f3db: 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 */ 10f3de: 8b 75 e4 mov -0x1c(%ebp),%esi <== NOT EXECUTED 10f3e1: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED bool _Protected_heap_Get_block_size( 10f3e4: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size 10f3e7: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED ); 10f3ea: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED 10f3ed: 89 58 08 mov %ebx,0x8(%eax) <== NOT EXECUTED 10f3f0: 89 59 0c mov %ebx,0xc(%ecx) <== NOT EXECUTED _Heap_Block_replace( next_block, the_block ); the_block->size = size | HEAP_PREV_USED; 10f3f3: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f3f5: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10f3f8: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block = _Heap_Block_at( the_block, size ); next_block->prev_size = size; 10f3fb: 89 14 13 mov %edx,(%ebx,%edx,1) <== NOT EXECUTED 10f3fe: eb bc jmp 10f3bc <_Heap_Free+0xc8> <== NOT EXECUTED bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ); 10f400: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED /** 10f403: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED * This routine returns the block of memory which begins 10f406: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10f409: 89 5f 08 mov %ebx,0x8(%edi) <== NOT EXECUTED 10f40c: 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; 10f40f: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10f412: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10f415: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block->size &= ~HEAP_PREV_USED; 10f418: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10f41b: 83 60 04 fe andl $0xfffffffe,0x4(%eax) <== NOT EXECUTED next_block->prev_size = the_size; 10f41f: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10f422: 89 10 mov %edx,(%eax) <== NOT EXECUTED stats->free_blocks += 1; 10f424: 8b 47 38 mov 0x38(%edi),%eax <== NOT EXECUTED 10f427: 40 inc %eax <== NOT EXECUTED 10f428: 89 47 38 mov %eax,0x38(%edi) <== NOT EXECUTED if ( stats->max_free_blocks < stats->free_blocks ) 10f42b: 3b 47 3c cmp 0x3c(%edi),%eax <== NOT EXECUTED 10f42e: 76 8c jbe 10f3bc <_Heap_Free+0xc8> <== NOT EXECUTED stats->max_free_blocks = stats->free_blocks; 10f430: 89 47 3c mov %eax,0x3c(%edi) <== NOT EXECUTED 10f433: eb 87 jmp 10f3bc <_Heap_Free+0xc8> <== 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; 10f435: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10f438: 03 55 f0 add -0x10(%ebp),%edx <== NOT EXECUTED prev_block->size = size | HEAP_PREV_USED; 10f43b: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f43d: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10f440: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block->size &= ~HEAP_PREV_USED; 10f443: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10f446: 83 60 04 fe andl $0xfffffffe,0x4(%eax) <== NOT EXECUTED next_block->prev_size = size; 10f44a: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10f44c: e9 6b ff ff ff jmp 10f3bc <_Heap_Free+0xc8> <== NOT EXECUTED 00126940 <_Heap_Get_free_information>: void _Heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 126940: 55 push %ebp <== NOT EXECUTED 126941: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126943: 53 push %ebx <== NOT EXECUTED 126944: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 126947: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED Heap_Block *the_block; Heap_Block *const tail = _Heap_Tail(the_heap); info->number = 0; 12694a: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED info->largest = 0; 126950: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED info->total = 0; 126957: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== 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( 12695e: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED for(the_block = _Heap_First(the_heap); the_block != tail; 126961: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 126963: 74 1d je 126982 <_Heap_Get_free_information+0x42> <== NOT EXECUTED 126965: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 126968: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 12696b: 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++; 12696e: ff 01 incl (%ecx) <== NOT EXECUTED info->total += the_size; 126970: 01 41 08 add %eax,0x8(%ecx) <== NOT EXECUTED if ( info->largest < the_size ) 126973: 39 41 04 cmp %eax,0x4(%ecx) <== NOT EXECUTED 126976: 73 03 jae 12697b <_Heap_Get_free_information+0x3b> <== NOT EXECUTED info->largest = the_size; 126978: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; the_block = the_block->next) 12697b: 8b 52 08 mov 0x8(%edx),%edx <== NOT EXECUTED info->number = 0; info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; 12697e: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 126980: 75 e6 jne 126968 <_Heap_Get_free_information+0x28> <== NOT EXECUTED info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 126982: 5b pop %ebx <== NOT EXECUTED 126983: c9 leave <== NOT EXECUTED 126984: c3 ret <== NOT EXECUTED 0012f734 <_Heap_Get_information>: Heap_Get_information_status _Heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 12f734: 55 push %ebp <== NOT EXECUTED 12f735: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f737: 56 push %esi <== NOT EXECUTED 12f738: 53 push %ebx <== NOT EXECUTED 12f739: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 12f73c: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED Heap_Block *the_block = the_heap->start; 12f73f: 8b 50 20 mov 0x20(%eax),%edx <== NOT EXECUTED Heap_Block *const end = the_heap->final; 12f742: 8b 70 24 mov 0x24(%eax),%esi <== NOT EXECUTED _HAssert(the_block->prev_size == HEAP_PREV_USED); _HAssert(_Heap_Is_prev_used(the_block)); the_info->Free.number = 0; 12f745: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED the_info->Free.total = 0; 12f74b: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED the_info->Free.largest = 0; 12f752: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED the_info->Used.number = 0; 12f759: c7 41 0c 00 00 00 00 movl $0x0,0xc(%ecx) <== NOT EXECUTED the_info->Used.total = 0; 12f760: c7 41 14 00 00 00 00 movl $0x0,0x14(%ecx) <== NOT EXECUTED the_info->Used.largest = 0; 12f767: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx) <== NOT EXECUTED while ( the_block != end ) { 12f76e: 39 f2 cmp %esi,%edx <== NOT EXECUTED 12f770: 74 42 je 12f7b4 <_Heap_Get_information+0x80> <== NOT EXECUTED 12f772: 8b 5a 04 mov 0x4(%edx),%ebx <== NOT EXECUTED 12f775: eb 13 jmp 12f78a <_Heap_Get_information+0x56> <== NOT EXECUTED 12f777: 90 nop <== NOT EXECUTED 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) ) { the_info->Used.number++; 12f778: ff 41 0c incl 0xc(%ecx) <== NOT EXECUTED the_info->Used.total += the_size; 12f77b: 01 41 14 add %eax,0x14(%ecx) <== NOT EXECUTED if ( the_info->Used.largest < the_size ) 12f77e: 39 41 10 cmp %eax,0x10(%ecx) <== NOT EXECUTED 12f781: 73 03 jae 12f786 <_Heap_Get_information+0x52> <== NOT EXECUTED the_info->Used.largest = the_size; 12f783: 89 41 10 mov %eax,0x10(%ecx) <== 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 ) { 12f786: 39 d6 cmp %edx,%esi <== NOT EXECUTED 12f788: 74 2a je 12f7b4 <_Heap_Get_information+0x80> <== NOT EXECUTED 12f78a: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12f78c: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 12f78f: 01 c2 add %eax,%edx <== NOT EXECUTED 12f791: 8b 5a 04 mov 0x4(%edx),%ebx <== NOT EXECUTED 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) ) { 12f794: f6 c3 01 test $0x1,%bl <== NOT EXECUTED 12f797: 75 df jne 12f778 <_Heap_Get_information+0x44> <== NOT EXECUTED the_info->Used.number++; the_info->Used.total += the_size; if ( the_info->Used.largest < the_size ) the_info->Used.largest = the_size; } else { the_info->Free.number++; 12f799: ff 01 incl (%ecx) <== NOT EXECUTED the_info->Free.total += the_size; 12f79b: 01 41 08 add %eax,0x8(%ecx) <== NOT EXECUTED if ( the_info->Free.largest < the_size ) 12f79e: 39 41 04 cmp %eax,0x4(%ecx) <== NOT EXECUTED 12f7a1: 73 03 jae 12f7a6 <_Heap_Get_information+0x72> <== NOT EXECUTED the_info->Free.largest = the_size; 12f7a3: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED if ( the_size != next_block->prev_size ) 12f7a6: 39 02 cmp %eax,(%edx) <== NOT EXECUTED 12f7a8: 74 dc je 12f786 <_Heap_Get_information+0x52> <== NOT EXECUTED 12f7aa: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED "used" as client never allocated it. Make 'Used.total' contain this blocks' overhead though. */ the_info->Used.total += HEAP_OVERHEAD; return HEAP_GET_INFORMATION_SUCCESSFUL; } 12f7af: 5b pop %ebx <== NOT EXECUTED 12f7b0: 5e pop %esi <== NOT EXECUTED 12f7b1: c9 leave <== NOT EXECUTED 12f7b2: c3 ret <== NOT EXECUTED 12f7b3: 90 nop <== 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; 12f7b4: 83 41 14 08 addl $0x8,0x14(%ecx) <== NOT EXECUTED 12f7b8: 31 c0 xor %eax,%eax <== NOT EXECUTED return HEAP_GET_INFORMATION_SUCCESSFUL; } 12f7ba: 5b pop %ebx <== NOT EXECUTED 12f7bb: 5e pop %esi <== NOT EXECUTED 12f7bc: c9 leave <== NOT EXECUTED 12f7bd: c3 ret <== NOT EXECUTED 0010b2f4 <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 10b2f4: 55 push %ebp <== NOT EXECUTED 10b2f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b2f7: 57 push %edi <== NOT EXECUTED 10b2f8: 56 push %esi <== NOT EXECUTED 10b2f9: 53 push %ebx <== NOT EXECUTED 10b2fa: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b2fd: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b300: 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) 10b303: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b305: 0f 85 fd 00 00 00 jne 10b408 <_Heap_Initialize+0x114> <== NOT EXECUTED 10b30b: b1 04 mov $0x4,%cl <== NOT EXECUTED 10b30d: 31 f6 xor %esi,%esi <== 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; 10b30f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10b312: 83 c3 08 add $0x8,%ebx <== NOT EXECUTED 10b315: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b317: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b319: f7 f1 div %ecx <== NOT EXECUTED 10b31b: 85 d2 test %edx,%edx <== NOT EXECUTED 10b31d: 74 05 je 10b324 <_Heap_Initialize+0x30> <== NOT EXECUTED 10b31f: 8d 1c 19 lea (%ecx,%ebx,1),%ebx <== NOT EXECUTED 10b322: 29 d3 sub %edx,%ebx <== NOT EXECUTED _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; 10b324: 83 eb 08 sub $0x8,%ebx <== 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 */ 10b327: 85 f6 test %esi,%esi <== NOT EXECUTED 10b329: 0f 85 cd 00 00 00 jne 10b3fc <_Heap_Initialize+0x108> <== NOT EXECUTED 10b32f: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 10b334: 89 47 14 mov %eax,0x14(%edi) <== 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); 10b337: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b339: 2b 45 0c sub 0xc(%ebp),%eax <== NOT EXECUTED 10b33c: 83 c0 08 add $0x8,%eax <== NOT EXECUTED if ( size < overhead ) 10b33f: 3b 45 10 cmp 0x10(%ebp),%eax <== NOT EXECUTED 10b342: 0f 87 a8 00 00 00 ja 10b3f0 <_Heap_Initialize+0xfc> <== NOT EXECUTED return 0; /* Too small area for the heap */ the_size = size - overhead; 10b348: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10b34b: 29 c6 sub %eax,%esi <== NOT EXECUTED * * @return free block information filled in. */ bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info 10b34d: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b34f: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b351: f7 f1 div %ecx <== NOT EXECUTED _Heap_Align_down ( &the_size, page_size ); if ( the_size == 0 ) 10b353: 29 d6 sub %edx,%esi <== NOT EXECUTED 10b355: 0f 84 95 00 00 00 je 10b3f0 <_Heap_Initialize+0xfc> <== NOT EXECUTED return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 10b35b: 89 4f 10 mov %ecx,0x10(%edi) <== NOT EXECUTED the_heap->begin = starting_address; 10b35e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b361: 89 47 18 mov %eax,0x18(%edi) <== NOT EXECUTED the_heap->end = starting_address + size; 10b364: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b367: 03 45 10 add 0x10(%ebp),%eax <== NOT EXECUTED 10b36a: 89 47 1c mov %eax,0x1c(%edi) <== NOT EXECUTED the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; 10b36d: 89 0b mov %ecx,(%ebx) <== NOT EXECUTED the_block->size = the_size | HEAP_PREV_USED; 10b36f: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b371: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10b374: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED the_block->next = _Heap_Tail( the_heap ); 10b377: 89 7b 08 mov %edi,0x8(%ebx) <== NOT EXECUTED the_block->prev = _Heap_Head( the_heap ); 10b37a: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED _Heap_Head(the_heap)->next = the_block; 10b37d: 89 5f 08 mov %ebx,0x8(%edi) <== NOT EXECUTED _Heap_Tail(the_heap)->prev = the_block; 10b380: 89 5f 0c mov %ebx,0xc(%edi) <== NOT EXECUTED the_heap->start = the_block; 10b383: 89 5f 20 mov %ebx,0x20(%edi) <== 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 10b386: 8d 04 33 lea (%ebx,%esi,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 */ 10b389: 89 47 24 mov %eax,0x24(%edi) <== NOT EXECUTED the_block->prev_size = the_size; /* Previous block is free */ 10b38c: 89 30 mov %esi,(%eax) <== NOT EXECUTED the_block->size = page_size; 10b38e: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED stats->size = size; 10b391: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b394: 89 47 2c mov %eax,0x2c(%edi) <== NOT EXECUTED stats->free_size = the_size; 10b397: 89 77 30 mov %esi,0x30(%edi) <== NOT EXECUTED stats->min_free_size = the_size; 10b39a: 89 77 34 mov %esi,0x34(%edi) <== NOT EXECUTED stats->free_blocks = 1; 10b39d: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi) <== NOT EXECUTED stats->max_free_blocks = 1; 10b3a4: c7 47 3c 01 00 00 00 movl $0x1,0x3c(%edi) <== NOT EXECUTED stats->used_blocks = 0; 10b3ab: c7 47 40 00 00 00 00 movl $0x0,0x40(%edi) <== NOT EXECUTED stats->max_search = 0; 10b3b2: c7 47 44 00 00 00 00 movl $0x0,0x44(%edi) <== NOT EXECUTED stats->allocs = 0; 10b3b9: c7 47 48 00 00 00 00 movl $0x0,0x48(%edi) <== NOT EXECUTED stats->searches = 0; 10b3c0: c7 47 4c 00 00 00 00 movl $0x0,0x4c(%edi) <== NOT EXECUTED stats->frees = 0; 10b3c7: c7 47 50 00 00 00 00 movl $0x0,0x50(%edi) <== NOT EXECUTED stats->resizes = 0; 10b3ce: c7 47 54 00 00 00 00 movl $0x0,0x54(%edi) <== NOT EXECUTED stats->instance = instance++; 10b3d5: a1 60 e7 11 00 mov 0x11e760,%eax <== NOT EXECUTED 10b3da: 89 47 28 mov %eax,0x28(%edi) <== NOT EXECUTED 10b3dd: 40 inc %eax <== NOT EXECUTED 10b3de: a3 60 e7 11 00 mov %eax,0x11e760 <== NOT EXECUTED return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 10b3e3: 8d 46 fc lea -0x4(%esi),%eax <== NOT EXECUTED } 10b3e6: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10b3e9: 5b pop %ebx <== NOT EXECUTED 10b3ea: 5e pop %esi <== NOT EXECUTED 10b3eb: 5f pop %edi <== NOT EXECUTED 10b3ec: c9 leave <== NOT EXECUTED 10b3ed: c3 ret <== NOT EXECUTED 10b3ee: 66 90 xchg %ax,%ax <== NOT EXECUTED stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 10b3f0: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10b3f2: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10b3f5: 5b pop %ebx <== NOT EXECUTED 10b3f6: 5e pop %esi <== NOT EXECUTED 10b3f7: 5f pop %edi <== NOT EXECUTED 10b3f8: c9 leave <== NOT EXECUTED 10b3f9: c3 ret <== NOT EXECUTED 10b3fa: 66 90 xchg %ax,%ax <== 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 */ 10b3fc: 8d 41 10 lea 0x10(%ecx),%eax <== NOT EXECUTED 10b3ff: 29 f0 sub %esi,%eax <== NOT EXECUTED 10b401: e9 2e ff ff ff jmp 10b334 <_Heap_Initialize+0x40> <== NOT EXECUTED 10b406: 66 90 xchg %ax,%ax <== NOT EXECUTED 10b408: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b40a: 83 e0 03 and $0x3,%eax <== NOT EXECUTED 10b40d: 74 05 je 10b414 <_Heap_Initialize+0x120> <== NOT EXECUTED 10b40f: 83 c1 04 add $0x4,%ecx <== NOT EXECUTED 10b412: 29 c1 sub %eax,%ecx <== NOT EXECUTED 10b414: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 10b419: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b41b: f7 f1 div %ecx <== NOT EXECUTED 10b41d: 89 d6 mov %edx,%esi <== NOT EXECUTED 10b41f: e9 eb fe ff ff jmp 10b30f <_Heap_Initialize+0x1b> <== NOT EXECUTED 00116a58 <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 116a58: 55 push %ebp <== NOT EXECUTED 116a59: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116a5b: 57 push %edi <== NOT EXECUTED 116a5c: 56 push %esi <== NOT EXECUTED 116a5d: 53 push %ebx <== NOT EXECUTED 116a5e: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 116a61: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 116a64: 8b 4d 0c mov 0xc(%ebp),%ecx <== 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; 116a67: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED 116a6a: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED uint32_t const page_size = the_heap->page_size; 116a6d: 8b 56 10 mov 0x10(%esi),%edx <== NOT EXECUTED 116a70: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED *old_mem_size = 0; 116a73: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 116a76: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED *avail_mem_size = 0; 116a7c: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 116a7f: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 116a85: 8d 59 f8 lea -0x8(%ecx),%ebx <== NOT EXECUTED 116a88: 89 c8 mov %ecx,%eax <== NOT EXECUTED 116a8a: 31 d2 xor %edx,%edx <== NOT EXECUTED 116a8c: f7 76 10 divl 0x10(%esi) <== NOT EXECUTED 116a8f: 29 d3 sub %edx,%ebx <== NOT EXECUTED 116a91: 8b 56 24 mov 0x24(%esi),%edx <== NOT EXECUTED 116a94: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 116a97: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 116a99: 72 04 jb 116a9f <_Heap_Resize_block+0x47> <== NOT EXECUTED 116a9b: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 116a9d: 76 0d jbe 116aac <_Heap_Resize_block+0x54> <== NOT EXECUTED } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 116a9f: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED } 116aa4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116aa7: 5b pop %ebx <== NOT EXECUTED 116aa8: 5e pop %esi <== NOT EXECUTED 116aa9: 5f pop %edi <== NOT EXECUTED 116aaa: c9 leave <== NOT EXECUTED 116aab: c3 ret <== 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; 116aac: 8b 7b 04 mov 0x4(%ebx),%edi <== NOT EXECUTED 116aaf: 89 7d cc mov %edi,-0x34(%ebp) <== NOT EXECUTED 116ab2: 83 e7 fe and $0xfffffffe,%edi <== NOT EXECUTED 116ab5: 89 7d d8 mov %edi,-0x28(%ebp) <== NOT EXECUTED 116ab8: 01 df add %ebx,%edi <== NOT EXECUTED 116aba: 89 7d c0 mov %edi,-0x40(%ebp) <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 116abd: 39 f8 cmp %edi,%eax <== NOT EXECUTED 116abf: 77 de ja 116a9f <_Heap_Resize_block+0x47> <== NOT EXECUTED 116ac1: 39 fa cmp %edi,%edx <== NOT EXECUTED 116ac3: 72 da jb 116a9f <_Heap_Resize_block+0x47> <== NOT EXECUTED 116ac5: 8b 47 04 mov 0x4(%edi),%eax <== 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) || 116ac8: a8 01 test $0x1,%al <== NOT EXECUTED 116aca: 74 d3 je 116a9f <_Heap_Resize_block+0x47> <== NOT EXECUTED 116acc: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 116acf: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 116ad2: 01 f8 add %edi,%eax <== NOT EXECUTED 116ad4: 89 45 d4 mov %eax,-0x2c(%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) || 116ad7: 39 fa cmp %edi,%edx <== NOT EXECUTED 116ad9: 0f 84 11 01 00 00 je 116bf0 <_Heap_Resize_block+0x198> <== NOT EXECUTED 116adf: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 116ae2: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 116ae5: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 116ae8: 88 45 f3 mov %al,-0xd(%ebp) <== 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; 116aeb: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED 116aee: 83 e7 01 and $0x1,%edi <== NOT EXECUTED 116af1: 89 7d dc mov %edi,-0x24(%ebp) <== NOT EXECUTED next_next_block = _Heap_Block_at(next_block, next_block_size); next_is_used = (next_block == the_heap->final) || _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) 116af4: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 116af7: 29 c8 sub %ecx,%eax <== NOT EXECUTED 116af9: 83 c0 04 add $0x4,%eax <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 116afc: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 116aff: 89 02 mov %eax,(%edx) <== NOT EXECUTED if (size > old_user_size) { 116b01: 3b 45 10 cmp 0x10(%ebp),%eax <== NOT EXECUTED 116b04: 73 3a jae 116b40 <_Heap_Resize_block+0xe8> <== 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 */ 116b06: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 116b0a: 75 29 jne 116b35 <_Heap_Resize_block+0xdd> <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; else { uint32_t add_block_size = size - old_user_size; 116b0c: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 116b0f: 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 116b11: 89 c8 mov %ecx,%eax <== NOT EXECUTED 116b13: 31 d2 xor %edx,%edx <== NOT EXECUTED 116b15: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED */ 116b18: 85 d2 test %edx,%edx <== NOT EXECUTED 116b1a: 74 05 je 116b21 <_Heap_Resize_block+0xc9> <== NOT EXECUTED 116b1c: 03 4d e4 add -0x1c(%ebp),%ecx <== NOT EXECUTED 116b1f: 29 d1 sub %edx,%ecx <== NOT EXECUTED 116b21: 89 c8 mov %ecx,%eax <== NOT EXECUTED 116b23: 3b 4d e0 cmp -0x20(%ebp),%ecx <== NOT EXECUTED 116b26: 0f 82 a0 00 00 00 jb 116bcc <_Heap_Resize_block+0x174> <== 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) 116b2c: 39 45 d0 cmp %eax,-0x30(%ebp) <== NOT EXECUTED 116b2f: 0f 83 9f 00 00 00 jae 116bd4 <_Heap_Resize_block+0x17c> <== NOT EXECUTED } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 116b35: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 116b3a: e9 65 ff ff ff jmp 116aa4 <_Heap_Resize_block+0x4c> <== NOT EXECUTED 116b3f: 90 nop <== NOT EXECUTED --stats->used_blocks; } } else { /* Calculate how much memory we could free */ uint32_t free_block_size = old_user_size - size; 116b40: 89 c1 mov %eax,%ecx <== NOT EXECUTED 116b42: 2b 4d 10 sub 0x10(%ebp),%ecx <== NOT EXECUTED * * @return free block information filled in. */ bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info 116b45: 89 c8 mov %ecx,%eax <== NOT EXECUTED 116b47: 31 d2 xor %edx,%edx <== NOT EXECUTED 116b49: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 116b4c: 29 d1 sub %edx,%ecx <== NOT EXECUTED 116b4e: 89 4d e8 mov %ecx,-0x18(%ebp) <== NOT EXECUTED 116b51: 74 69 je 116bbc <_Heap_Resize_block+0x164> <== 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; 116b53: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 116b56: 29 ca sub %ecx,%edx <== NOT EXECUTED 116b58: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED if (new_block_size < min_block_size) { 116b5b: 39 55 e0 cmp %edx,-0x20(%ebp) <== NOT EXECUTED 116b5e: 76 0d jbe 116b6d <_Heap_Resize_block+0x115> <== NOT EXECUTED uint32_t delta = min_block_size - new_block_size; 116b60: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 116b63: 29 d0 sub %edx,%eax <== NOT EXECUTED _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 116b65: 29 45 e8 sub %eax,-0x18(%ebp) <== NOT EXECUTED 116b68: 74 52 je 116bbc <_Heap_Resize_block+0x164> <== NOT EXECUTED ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; } new_block_size += delta; 116b6a: 01 45 ec add %eax,-0x14(%ebp) <== 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) { 116b6d: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 116b71: 0f 85 85 00 00 00 jne 116bfc <_Heap_Resize_block+0x1a4> <== NOT EXECUTED 116b77: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 116b7a: 8d 14 3b lea (%ebx,%edi,1),%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; 116b7d: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 116b80: 03 4d d0 add -0x30(%ebp),%ecx <== NOT EXECUTED _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; 116b83: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 116b86: 09 c7 or %eax,%edi <== NOT EXECUTED 116b88: 89 7b 04 mov %edi,0x4(%ebx) <== NOT EXECUTED new_next_block->size = new_next_block_size | HEAP_PREV_USED; 116b8b: 89 c8 mov %ecx,%eax <== NOT EXECUTED 116b8d: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 116b90: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED next_next_block->prev_size = new_next_block_size; 116b93: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED 116b96: 89 0f mov %ecx,(%edi) <== 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 */ 116b98: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 116b9b: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED bool _Protected_heap_Get_block_size( 116b9e: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size 116ba1: 89 5a 08 mov %ebx,0x8(%edx) <== NOT EXECUTED ); 116ba4: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED 116ba7: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED 116baa: 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; 116bad: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 116bb0: 01 46 30 add %eax,0x30(%esi) <== NOT EXECUTED *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 116bb3: 83 e9 04 sub $0x4,%ecx <== NOT EXECUTED 116bb6: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 116bb9: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 116bbb: 90 nop <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; } } } ++stats->resizes; 116bbc: ff 46 54 incl 0x54(%esi) <== NOT EXECUTED 116bbf: 31 c0 xor %eax,%eax <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; } 116bc1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116bc4: 5b pop %ebx <== NOT EXECUTED 116bc5: 5e pop %esi <== NOT EXECUTED 116bc6: 5f pop %edi <== NOT EXECUTED 116bc7: c9 leave <== NOT EXECUTED 116bc8: c3 ret <== NOT EXECUTED 116bc9: 8d 76 00 lea 0x0(%esi),%esi <== 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 */ 116bcc: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 116bcf: e9 58 ff ff ff jmp 116b2c <_Heap_Resize_block+0xd4> <== 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) return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */ add_block_size = 116bd4: 52 push %edx <== NOT EXECUTED 116bd5: 50 push %eax <== NOT EXECUTED 116bd6: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED 116bd9: 56 push %esi <== NOT EXECUTED 116bda: e8 79 48 ff ff call 10b458 <_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; 116bdf: 03 45 d8 add -0x28(%ebp),%eax <== NOT EXECUTED 116be2: 0b 45 dc or -0x24(%ebp),%eax <== NOT EXECUTED 116be5: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED --stats->used_blocks; 116be8: ff 4e 40 decl 0x40(%esi) <== NOT EXECUTED 116beb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116bee: eb cc jmp 116bbc <_Heap_Resize_block+0x164> <== 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) || 116bf0: c6 45 f3 01 movb $0x1,-0xd(%ebp) <== NOT EXECUTED 116bf4: e9 f2 fe ff ff jmp 116aeb <_Heap_Resize_block+0x93> <== NOT EXECUTED 116bf9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED next_next_block->prev_size = new_next_block_size; _Heap_Block_replace(next_block, new_next_block); the_heap->stats.free_size += free_block_size; *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; } else if (free_block_size >= min_block_size) { 116bfc: 8b 7d e8 mov -0x18(%ebp),%edi <== NOT EXECUTED 116bff: 39 7d e0 cmp %edi,-0x20(%ebp) <== NOT EXECUTED 116c02: 77 b8 ja 116bbc <_Heap_Resize_block+0x164> <== NOT EXECUTED /* Split the block into 2 used parts, then free the second one. */ the_block->size = new_block_size | prev_used_flag; 116c04: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 116c07: 09 45 dc or %eax,-0x24(%ebp) <== NOT EXECUTED 116c0a: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 116c0d: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED 116c10: 8d 04 03 lea (%ebx,%eax,1),%eax <== NOT EXECUTED next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; 116c13: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 116c16: 83 ca 01 or $0x1,%edx <== NOT EXECUTED 116c19: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 116c1c: ff 46 40 incl 0x40(%esi) <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 116c1f: ff 4e 50 decl 0x50(%esi) <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 116c22: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 116c25: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 116c28: 50 push %eax <== NOT EXECUTED 116c29: 56 push %esi <== NOT EXECUTED 116c2a: e8 c5 86 ff ff call 10f2f4 <_Heap_Free> <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 116c2f: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 116c32: 83 e8 04 sub $0x4,%eax <== NOT EXECUTED 116c35: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 116c38: 89 02 mov %eax,(%edx) <== NOT EXECUTED 116c3a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116c3d: e9 7a ff ff ff jmp 116bbc <_Heap_Resize_block+0x164> <== NOT EXECUTED 00116c44 <_Heap_Size_of_user_area>: bool _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 116c44: 55 push %ebp <== NOT EXECUTED 116c45: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116c47: 57 push %edi <== NOT EXECUTED 116c48: 56 push %esi <== NOT EXECUTED 116c49: 53 push %ebx <== NOT EXECUTED 116c4a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 116c4d: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Heap_Block *the_block; Heap_Block *next_block; uint32_t the_size; if ( !_Addresses_Is_in_range( 116c50: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 116c53: 8b 70 24 mov 0x24(%eax),%esi <== NOT EXECUTED 116c56: 8b 48 20 mov 0x20(%eax),%ecx <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 116c59: 39 f9 cmp %edi,%ecx <== NOT EXECUTED 116c5b: 77 04 ja 116c61 <_Heap_Size_of_user_area+0x1d> <== NOT EXECUTED 116c5d: 39 fe cmp %edi,%esi <== NOT EXECUTED 116c5f: 73 0b jae 116c6c <_Heap_Size_of_user_area+0x28> <== NOT EXECUTED area of 'the_block'. */ *size = _Addresses_Subtract ( next_block, starting_address ) + HEAP_BLOCK_HEADER_OFFSET; return( TRUE ); 116c61: 31 c0 xor %eax,%eax <== NOT EXECUTED } 116c63: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 116c66: 5b pop %ebx <== NOT EXECUTED 116c67: 5e pop %esi <== NOT EXECUTED 116c68: 5f pop %edi <== NOT EXECUTED 116c69: c9 leave <== NOT EXECUTED 116c6a: c3 ret <== NOT EXECUTED 116c6b: 90 nop <== NOT EXECUTED 116c6c: 8d 57 f8 lea -0x8(%edi),%edx <== NOT EXECUTED 116c6f: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 116c72: 89 f8 mov %edi,%eax <== NOT EXECUTED 116c74: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 116c77: 31 d2 xor %edx,%edx <== NOT EXECUTED 116c79: f7 73 10 divl 0x10(%ebx) <== NOT EXECUTED 116c7c: 29 55 e8 sub %edx,-0x18(%ebp) <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 116c7f: 3b 4d e8 cmp -0x18(%ebp),%ecx <== NOT EXECUTED 116c82: 77 dd ja 116c61 <_Heap_Size_of_user_area+0x1d> <== NOT EXECUTED 116c84: 3b 75 e8 cmp -0x18(%ebp),%esi <== NOT EXECUTED 116c87: 72 d8 jb 116c61 <_Heap_Size_of_user_area+0x1d> <== NOT EXECUTED 116c89: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 116c8c: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 116c8f: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 116c92: 01 d0 add %edx,%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 116c94: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 116c96: 77 c9 ja 116c61 <_Heap_Size_of_user_area+0x1d> <== NOT EXECUTED 116c98: 39 c6 cmp %eax,%esi <== NOT EXECUTED 116c9a: 72 c5 jb 116c61 <_Heap_Size_of_user_area+0x1d> <== 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 ( 116c9c: f6 40 04 01 testb $0x1,0x4(%eax) <== NOT EXECUTED 116ca0: 74 bf je 116c61 <_Heap_Size_of_user_area+0x1d> <== 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 ) 116ca2: 29 f8 sub %edi,%eax <== NOT EXECUTED 116ca4: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 116ca7: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 116caa: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 116cac: b0 01 mov $0x1,%al <== NOT EXECUTED 116cae: eb b3 jmp 116c63 <_Heap_Size_of_user_area+0x1f> <== NOT EXECUTED 001115dc <_Heap_Walk>: bool _Heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 1115dc: 55 push %ebp <== NOT EXECUTED 1115dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1115df: 57 push %edi <== NOT EXECUTED 1115e0: 56 push %esi <== NOT EXECUTED 1115e1: 53 push %ebx <== NOT EXECUTED 1115e2: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1115e5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Heap_Block *the_block = the_heap->start; 1115e8: 8b 7e 20 mov 0x20(%esi),%edi <== NOT EXECUTED Heap_Block *const end = the_heap->final; 1115eb: 8b 46 24 mov 0x24(%esi),%eax <== NOT EXECUTED 1115ee: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED /* if ( !_System_state_Is_up( _System_state_Get() ) ) return TRUE; */ if (source < 0) 1115f1: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1115f4: 85 c0 test %eax,%eax <== NOT EXECUTED 1115f6: 0f 88 67 02 00 00 js 111863 <_Heap_Walk+0x287> <== NOT EXECUTED /* * Handle the 1st block */ if (!_Heap_Is_prev_used(the_block)) { 1115fc: f6 47 04 01 testb $0x1,0x4(%edi) <== NOT EXECUTED 111600: 0f 84 3e 02 00 00 je 111844 <_Heap_Walk+0x268> <== NOT EXECUTED 111606: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp) <== NOT EXECUTED printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source); error = 1; } if (the_block->prev_size != the_heap->page_size) { 11160d: 8b 07 mov (%edi),%eax <== NOT EXECUTED 11160f: 3b 46 10 cmp 0x10(%esi),%eax <== NOT EXECUTED 111612: 74 1a je 11162e <_Heap_Walk+0x52> <== NOT EXECUTED printk("PASS: %d !prev_size of 1st block isn't page_size\n", source); 111614: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111617: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11161a: 68 e8 ca 11 00 push $0x11cae8 <== NOT EXECUTED 11161f: e8 5c 7d ff ff call 109380 <== NOT EXECUTED 111624: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 11162b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } while ( the_block != end ) { 11162e: 3b 7d e4 cmp -0x1c(%ebp),%edi <== NOT EXECUTED 111631: 0f 84 37 02 00 00 je 11186e <_Heap_Walk+0x292> <== NOT EXECUTED 111637: 8b 57 04 mov 0x4(%edi),%edx <== NOT EXECUTED 11163a: 89 d3 mov %edx,%ebx <== NOT EXECUTED 11163c: 83 e3 fe and $0xfffffffe,%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 11163f: 8d 04 1f lea (%edi,%ebx,1),%eax <== NOT EXECUTED 111642: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 111645: 8b 46 24 mov 0x24(%esi),%eax <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 111648: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 11164b: 39 4e 20 cmp %ecx,0x20(%esi) <== NOT EXECUTED 11164e: 0f 87 14 01 00 00 ja 111768 <_Heap_Walk+0x18c> <== NOT EXECUTED 111654: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 111656: 0f 87 0c 01 00 00 ja 111768 <_Heap_Walk+0x18c> <== NOT EXECUTED 11165c: 83 e2 01 and $0x1,%edx <== NOT EXECUTED 11165f: 88 55 f3 mov %dl,-0xd(%ebp) <== NOT EXECUTED 111662: 66 90 xchg %ax,%ax <== NOT EXECUTED printk("PASS: %d !block %p is out of heap\n", source, next_block); error = 1; break; } if (!_Heap_Is_prev_used(next_block)) { 111664: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 111667: f6 41 04 01 testb $0x1,0x4(%ecx) <== NOT EXECUTED 11166b: 0f 85 53 01 00 00 jne 1117c4 <_Heap_Walk+0x1e8> <== 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) { 111671: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 111674: 39 18 cmp %ebx,(%eax) <== NOT EXECUTED 111676: 74 1a je 111692 <_Heap_Walk+0xb6> <== NOT EXECUTED if (do_dump) printk("\n"); printk("PASS: %d !front and back sizes don't match", source); 111678: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11167b: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11167e: 68 40 cb 11 00 push $0x11cb40 <== NOT EXECUTED 111683: e8 f8 7c ff ff call 109380 <== NOT EXECUTED 111688: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 11168f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } if (!prev_used) { 111692: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 111696: 75 25 jne 1116bd <_Heap_Walk+0xe1> <== NOT EXECUTED if (do_dump || error) printk("\n"); 111698: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 11169b: 85 c0 test %eax,%eax <== NOT EXECUTED 11169d: 0f 85 81 01 00 00 jne 111824 <_Heap_Walk+0x248> <== NOT EXECUTED printk("PASS: %d !two consecutive blocks are free", source); 1116a3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1116a6: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1116a9: 68 6c cb 11 00 push $0x11cb6c <== NOT EXECUTED 1116ae: e8 cd 7c ff ff call 109380 <== NOT EXECUTED 1116b3: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 1116ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { return ( the_thread == _Thread_Heir ); } /** 1116bd: 8b 46 08 mov 0x8(%esi),%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) 1116c0: 39 c7 cmp %eax,%edi <== NOT EXECUTED 1116c2: 75 13 jne 1116d7 <_Heap_Walk+0xfb> <== NOT EXECUTED 1116c4: e9 fb 00 00 00 jmp 1117c4 <_Heap_Walk+0x1e8> <== NOT EXECUTED 1116c9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED block = block->next; 1116cc: 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) 1116cf: 39 f8 cmp %edi,%eax <== NOT EXECUTED 1116d1: 0f 84 ed 00 00 00 je 1117c4 <_Heap_Walk+0x1e8> <== NOT EXECUTED 1116d7: 39 c6 cmp %eax,%esi <== NOT EXECUTED 1116d9: 75 f1 jne 1116cc <_Heap_Walk+0xf0> <== NOT EXECUTED block = block->next; if(block != the_block) { if (do_dump || error) printk("\n"); 1116db: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 1116de: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1116e0: 74 10 je 1116f2 <_Heap_Walk+0x116> <== NOT EXECUTED 1116e2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1116e5: 68 e7 a6 11 00 push $0x11a6e7 <== NOT EXECUTED 1116ea: e8 91 7c ff ff call 109380 <== NOT EXECUTED 1116ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED printk("PASS: %d !the_block not in the free list", source); 1116f2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1116f5: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1116f8: 68 98 cb 11 00 push $0x11cb98 <== NOT EXECUTED 1116fd: e8 7e 7c ff ff call 109380 <== NOT EXECUTED 111702: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111709: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } } } if (do_dump || error) printk("\n"); 11170c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11170f: 68 e7 a6 11 00 push $0x11a6e7 <== NOT EXECUTED 111714: e8 67 7c ff ff call 109380 <== NOT EXECUTED 111719: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (the_size < the_heap->min_block_size) { 11171c: 3b 5e 14 cmp 0x14(%esi),%ebx <== NOT EXECUTED 11171f: 0f 82 b3 00 00 00 jb 1117d8 <_Heap_Walk+0x1fc> <== NOT EXECUTED printk("PASS: %d !block size is too small\n", source); error = 1; break; } if (!_Heap_Is_aligned( the_size, the_heap->page_size)) { 111725: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111727: 31 d2 xor %edx,%edx <== NOT EXECUTED 111729: f7 76 10 divl 0x10(%esi) <== NOT EXECUTED 11172c: 85 d2 test %edx,%edx <== NOT EXECUTED 11172e: 0f 85 d8 00 00 00 jne 11180c <_Heap_Walk+0x230> <== NOT EXECUTED printk("PASS: %d !block size is misaligned\n", source); error = 1; } if (++passes > (do_dump ? 10 : 0) && error) 111734: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 111737: 85 c0 test %eax,%eax <== NOT EXECUTED 111739: 75 41 jne 11177c <_Heap_Walk+0x1a0> <== 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 ) { 11173b: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 11173e: 39 4d e4 cmp %ecx,-0x1c(%ebp) <== NOT EXECUTED 111741: 0f 84 27 01 00 00 je 11186e <_Heap_Walk+0x292> <== NOT EXECUTED 111747: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11174a: 8b 48 04 mov 0x4(%eax),%ecx <== NOT EXECUTED 11174d: 89 cb mov %ecx,%ebx <== NOT EXECUTED 11174f: 83 e3 fe and $0xfffffffe,%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 ); 111752: 01 d8 add %ebx,%eax <== NOT EXECUTED 111754: 8b 56 24 mov 0x24(%esi),%edx <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 111757: 3b 46 20 cmp 0x20(%esi),%eax <== NOT EXECUTED 11175a: 0f 83 90 00 00 00 jae 1117f0 <_Heap_Walk+0x214> <== NOT EXECUTED printk("PASS: %d !block %p is out of heap\n", source, next_block); error = 1; break; } if (!_Heap_Is_prev_used(next_block)) { 111760: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 111763: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 111766: 66 90 xchg %ax,%ax <== NOT EXECUTED printk(" (prev_size) %d", the_block->prev_size); } if (!_Heap_Is_block_in(the_heap, next_block)) { if (do_dump) printk("\n"); printk("PASS: %d !block %p is out of heap\n", source, next_block); 111768: 50 push %eax <== NOT EXECUTED 111769: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 11176c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11176f: 68 1c cb 11 00 push $0x11cb1c <== NOT EXECUTED 111774: e8 07 7c ff ff call 109380 <== NOT EXECUTED 111779: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_block = next_block; } if (the_block != end) { printk("PASS: %d !last block address isn't equal to 'final' %p %p\n", 11177c: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 11177f: 57 push %edi <== NOT EXECUTED 111780: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111783: 68 0c cc 11 00 push $0x11cc0c <== NOT EXECUTED 111788: e8 f3 7b ff ff call 109380 <== NOT EXECUTED 11178d: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111794: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111797: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 11179a: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED source, the_block, end); error = 1; } if (_Heap_Block_size(the_block) != the_heap->page_size) { 11179d: 8b 56 10 mov 0x10(%esi),%edx <== NOT EXECUTED 1117a0: 39 c2 cmp %eax,%edx <== NOT EXECUTED 1117a2: 0f 84 91 00 00 00 je 111839 <_Heap_Walk+0x25d> <== NOT EXECUTED printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source, 1117a8: 52 push %edx <== NOT EXECUTED 1117a9: 50 push %eax <== NOT EXECUTED 1117aa: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1117ad: 68 48 cc 11 00 push $0x11cc48 <== NOT EXECUTED 1117b2: e8 c9 7b ff ff call 109380 <== NOT EXECUTED 1117b7: b0 01 mov $0x1,%al <== NOT EXECUTED 1117b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if(do_dump && error) _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 ); return error; } 1117bc: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1117bf: 5b pop %ebx <== NOT EXECUTED 1117c0: 5e pop %esi <== NOT EXECUTED 1117c1: 5f pop %edi <== NOT EXECUTED 1117c2: c9 leave <== NOT EXECUTED 1117c3: c3 ret <== NOT EXECUTED error = 1; } } } if (do_dump || error) printk("\n"); 1117c4: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 1117c7: 85 d2 test %edx,%edx <== NOT EXECUTED 1117c9: 0f 85 3d ff ff ff jne 11170c <_Heap_Walk+0x130> <== NOT EXECUTED if (the_size < the_heap->min_block_size) { 1117cf: 3b 5e 14 cmp 0x14(%esi),%ebx <== NOT EXECUTED 1117d2: 0f 83 4d ff ff ff jae 111725 <_Heap_Walk+0x149> <== NOT EXECUTED printk("PASS: %d !block size is too small\n", source); 1117d8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1117db: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1117de: 68 c4 cb 11 00 push $0x11cbc4 <== NOT EXECUTED 1117e3: e8 98 7b ff ff call 109380 <== NOT EXECUTED 1117e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1117eb: eb 8f jmp 11177c <_Heap_Walk+0x1a0> <== NOT EXECUTED 1117ed: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 1117f0: 39 d0 cmp %edx,%eax <== NOT EXECUTED 1117f2: 0f 87 68 ff ff ff ja 111760 <_Heap_Walk+0x184> <== NOT EXECUTED 1117f8: 83 e1 01 and $0x1,%ecx <== NOT EXECUTED 1117fb: 88 4d f3 mov %cl,-0xd(%ebp) <== NOT EXECUTED 1117fe: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 111801: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 111804: e9 5b fe ff ff jmp 111664 <_Heap_Walk+0x88> <== NOT EXECUTED 111809: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED error = 1; break; } if (!_Heap_Is_aligned( the_size, the_heap->page_size)) { printk("PASS: %d !block size is misaligned\n", source); 11180c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11180f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111812: 68 e8 cb 11 00 push $0x11cbe8 <== NOT EXECUTED 111817: e8 64 7b ff ff call 109380 <== NOT EXECUTED 11181c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11181f: e9 58 ff ff ff jmp 11177c <_Heap_Walk+0x1a0> <== NOT EXECUTED if (do_dump) printk("\n"); printk("PASS: %d !front and back sizes don't match", source); error = 1; } if (!prev_used) { if (do_dump || error) printk("\n"); 111824: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111827: 68 e7 a6 11 00 push $0x11a6e7 <== NOT EXECUTED 11182c: e8 4f 7b ff ff call 109380 <== NOT EXECUTED 111831: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111834: e9 6a fe ff ff jmp 1116a3 <_Heap_Walk+0xc7> <== NOT EXECUTED printk("PASS: %d !last block address isn't equal to 'final' %p %p\n", source, the_block, end); error = 1; } if (_Heap_Block_size(the_block) != the_heap->page_size) { 111839: 8a 45 e8 mov -0x18(%ebp),%al <== NOT EXECUTED if(do_dump && error) _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 ); return error; } 11183c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11183f: 5b pop %ebx <== NOT EXECUTED 111840: 5e pop %esi <== NOT EXECUTED 111841: 5f pop %edi <== NOT EXECUTED 111842: c9 leave <== NOT EXECUTED 111843: c3 ret <== NOT EXECUTED /* * Handle the 1st block */ if (!_Heap_Is_prev_used(the_block)) { printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source); 111844: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111847: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11184a: 68 b0 ca 11 00 push $0x11cab0 <== NOT EXECUTED 11184f: e8 2c 7b ff ff call 109380 <== NOT EXECUTED 111854: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 11185b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11185e: e9 aa fd ff ff jmp 11160d <_Heap_Walk+0x31> <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) return TRUE; */ if (source < 0) source = the_heap->stats.instance; 111863: 8b 4e 28 mov 0x28(%esi),%ecx <== NOT EXECUTED 111866: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED 111869: e9 8e fd ff ff jmp 1115fc <_Heap_Walk+0x20> <== NOT EXECUTED source, the_block, end); error = 1; } if (_Heap_Block_size(the_block) != the_heap->page_size) { printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source, 11186e: 8b 7d e4 mov -0x1c(%ebp),%edi <== NOT EXECUTED 111871: e9 21 ff ff ff jmp 111797 <_Heap_Walk+0x1bb> <== NOT EXECUTED 0010aa54 <_IO_Initialize_all_drivers>: * * Output Parameters: NONE */ void _IO_Initialize_all_drivers( void ) { 10aa54: 55 push %ebp <== NOT EXECUTED 10aa55: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa57: 53 push %ebx <== NOT EXECUTED 10aa58: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10aa5b: 8b 15 a0 ed 11 00 mov 0x11eda0,%edx <== NOT EXECUTED 10aa61: 85 d2 test %edx,%edx <== NOT EXECUTED 10aa63: 74 1a je 10aa7f <_IO_Initialize_all_drivers+0x2b> <== NOT EXECUTED 10aa65: 31 db xor %ebx,%ebx <== NOT EXECUTED 10aa67: 90 nop <== NOT EXECUTED (void) rtems_io_initialize( major, 0, NULL ); 10aa68: 50 push %eax <== NOT EXECUTED 10aa69: 6a 00 push $0x0 <== NOT EXECUTED 10aa6b: 6a 00 push $0x0 <== NOT EXECUTED 10aa6d: 53 push %ebx <== NOT EXECUTED 10aa6e: e8 29 45 00 00 call 10ef9c <== NOT EXECUTED void _IO_Initialize_all_drivers( void ) { rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10aa73: 43 inc %ebx <== NOT EXECUTED 10aa74: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aa77: 39 1d a0 ed 11 00 cmp %ebx,0x11eda0 <== NOT EXECUTED 10aa7d: 77 e9 ja 10aa68 <_IO_Initialize_all_drivers+0x14> <== NOT EXECUTED (void) rtems_io_initialize( major, 0, NULL ); } 10aa7f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10aa82: c9 leave <== NOT EXECUTED 10aa83: c3 ret <== NOT EXECUTED 0010aa84 <_IO_Manager_initialization>: void _IO_Manager_initialization( rtems_driver_address_table *driver_table, uint32_t drivers_in_table, uint32_t number_of_drivers ) { 10aa84: 55 push %ebp <== NOT EXECUTED 10aa85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa87: 57 push %edi <== NOT EXECUTED 10aa88: 56 push %esi <== NOT EXECUTED 10aa89: 53 push %ebx <== NOT EXECUTED 10aa8a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa8d: 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 ) 10aa90: 3b 75 0c cmp 0xc(%ebp),%esi <== NOT EXECUTED 10aa93: 76 5b jbe 10aaf0 <_IO_Manager_initialization+0x6c> <== 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 *) 10aa95: 8d 04 76 lea (%esi,%esi,2),%eax <== NOT EXECUTED 10aa98: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx <== NOT EXECUTED 10aa9f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aaa2: 53 push %ebx <== NOT EXECUTED 10aaa3: e8 4c 29 00 00 call 10d3f4 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10aaa8: 89 c7 mov %eax,%edi <== NOT EXECUTED 10aaaa: a3 a4 ed 11 00 mov %eax,0x11eda4 <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; 10aaaf: 89 35 a0 ed 11 00 mov %esi,0x11eda0 <== NOT EXECUTED memset( 10aab5: 31 c0 xor %eax,%eax <== NOT EXECUTED 10aab7: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 10aab9: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 10aabb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aabe: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10aac1: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10aac3: 74 23 je 10aae8 <_IO_Manager_initialization+0x64> <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 10aac5: 8b 1d a4 ed 11 00 mov 0x11eda4,%ebx <== NOT EXECUTED 10aacb: 31 d2 xor %edx,%edx <== NOT EXECUTED 10aacd: 31 c0 xor %eax,%eax <== NOT EXECUTED 10aacf: 90 nop <== NOT EXECUTED 10aad0: 8d 3c 03 lea (%ebx,%eax,1),%edi <== NOT EXECUTED 10aad3: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10aad6: 01 c6 add %eax,%esi <== NOT EXECUTED 10aad8: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10aadd: 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++ ) 10aadf: 42 inc %edx <== NOT EXECUTED 10aae0: 83 c0 18 add $0x18,%eax <== NOT EXECUTED 10aae3: 39 55 0c cmp %edx,0xc(%ebp) <== NOT EXECUTED 10aae6: 77 e8 ja 10aad0 <_IO_Manager_initialization+0x4c> <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; number_of_drivers = drivers_in_table; } 10aae8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aaeb: 5b pop %ebx <== NOT EXECUTED 10aaec: 5e pop %esi <== NOT EXECUTED 10aaed: 5f pop %edi <== NOT EXECUTED 10aaee: c9 leave <== NOT EXECUTED 10aaef: c3 ret <== 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; 10aaf0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10aaf3: a3 a4 ed 11 00 mov %eax,0x11eda4 <== NOT EXECUTED _IO_Number_of_drivers = number_of_drivers; 10aaf8: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10aafb: 89 0d a0 ed 11 00 mov %ecx,0x11eda0 <== NOT EXECUTED ); for ( index = 0 ; index < drivers_in_table ; index++ ) _IO_Driver_address_table[index] = driver_table[index]; number_of_drivers = drivers_in_table; } 10ab01: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ab04: 5b pop %ebx <== NOT EXECUTED 10ab05: 5e pop %esi <== NOT EXECUTED 10ab06: 5f pop %edi <== NOT EXECUTED 10ab07: c9 leave <== NOT EXECUTED 10ab08: c3 ret <== NOT EXECUTED 0010b51c <_ISR_Handler_initialization>: * * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { 10b51c: 55 push %ebp <== NOT EXECUTED 10b51d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b51f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED _ISR_Signals_to_thread_executing = FALSE; 10b522: c6 05 68 eb 11 00 00 movb $0x0,0x11eb68 <== NOT EXECUTED _ISR_Nest_level = 0; 10b529: c7 05 98 ea 11 00 00 movl $0x0,0x11ea98 <== NOT EXECUTED 10b530: 00 00 00 <== NOT EXECUTED _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( !_Stack_Is_enough(_Configuration_Table->interrupt_stack_size) ) 10b533: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10b538: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10b53b: 3b 05 b0 a4 11 00 cmp 0x11a4b0,%eax <== NOT EXECUTED 10b541: 72 21 jb 10b564 <_ISR_Handler_initialization+0x48> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = _Workspace_Allocate_or_fatal_error( 10b543: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b546: 50 push %eax <== NOT EXECUTED 10b547: e8 a8 1e 00 00 call 10d3f4 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10b54c: a3 08 ea 11 00 mov %eax,0x11ea08 <== NOT EXECUTED _Configuration_Table->interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 10b551: 8b 15 94 ea 11 00 mov 0x11ea94,%edx <== NOT EXECUTED 10b557: 03 42 1c add 0x1c(%edx),%eax <== NOT EXECUTED 10b55a: a3 c8 e9 11 00 mov %eax,0x11e9c8 <== NOT EXECUTED 10b55f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE ) _CPU_Install_interrupt_stack(); #endif } 10b562: c9 leave <== NOT EXECUTED 10b563: c3 ret <== NOT EXECUTED _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( !_Stack_Is_enough(_Configuration_Table->interrupt_stack_size) ) _Internal_error_Occurred( 10b564: 50 push %eax <== NOT EXECUTED 10b565: 6a 05 push $0x5 <== NOT EXECUTED 10b567: 6a 01 push $0x1 <== NOT EXECUTED 10b569: 6a 00 push $0x0 <== NOT EXECUTED 10b56b: e8 6c ff ff ff call 10b4dc <_Internal_error_Occurred> <== NOT EXECUTED 0010b4dc <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) { 10b4dc: 55 push %ebp <== NOT EXECUTED 10b4dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4df: 53 push %ebx <== NOT EXECUTED 10b4e0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b4e3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b4e6: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b4e9: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED _Internal_errors_What_happened.the_source = the_source; 10b4ec: 89 15 a4 ea 11 00 mov %edx,0x11eaa4 <== NOT EXECUTED _Internal_errors_What_happened.is_internal = is_internal; 10b4f2: a2 a8 ea 11 00 mov %al,0x11eaa8 <== NOT EXECUTED _Internal_errors_What_happened.the_error = the_error; 10b4f7: 89 1d ac ea 11 00 mov %ebx,0x11eaac <== NOT EXECUTED _User_extensions_Fatal( the_source, is_internal, the_error ); 10b4fd: 53 push %ebx <== NOT EXECUTED 10b4fe: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10b501: 50 push %eax <== NOT EXECUTED 10b502: 52 push %edx <== NOT EXECUTED 10b503: e8 60 1b 00 00 call 10d068 <_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( 10b508: c7 05 c4 eb 11 00 05 movl $0x5,0x11ebc4 <== NOT EXECUTED 10b50f: 00 00 00 <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10b512: fa cli <== NOT EXECUTED 10b513: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b515: f4 hlt <== NOT EXECUTED 10b516: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b519: eb fe jmp 10b519 <_Internal_error_Occurred+0x3d> <== NOT EXECUTED 0010ec0c <_Interrupt_Manager_initialization>: * * Output parameters: NONE */ void _Interrupt_Manager_initialization( void ) { 10ec0c: 55 push %ebp <== NOT EXECUTED 10ec0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED } 10ec0f: c9 leave <== NOT EXECUTED 10ec10: c3 ret <== NOT EXECUTED 001259bc <_Message_queue_Allocate>: * Output parameters: * the_message_queue - set if successful, NULL otherwise */ Message_queue_Control *_Message_queue_Allocate(void) { 1259bc: 55 push %ebp <== NOT EXECUTED 1259bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1259bf: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED return (Message_queue_Control *) 1259c2: 68 a0 16 16 00 push $0x1616a0 <== NOT EXECUTED 1259c7: e8 20 ae fe ff call 1107ec <_Objects_Allocate> <== NOT EXECUTED _Objects_Allocate(&_Message_queue_Information); } 1259cc: c9 leave <== NOT EXECUTED 1259cd: c3 ret <== NOT EXECUTED 0010ec14 <_Message_queue_Manager_initialization>: */ void _Message_queue_Manager_initialization( uint32_t maximum_message_queues ) { 10ec14: 55 push %ebp <== NOT EXECUTED 10ec15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ec17: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ec1a: 6a 04 push $0x4 <== NOT EXECUTED 10ec1c: 6a 00 push $0x0 <== NOT EXECUTED 10ec1e: 68 88 00 00 00 push $0x88 <== NOT EXECUTED 10ec23: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ec26: 6a 04 push $0x4 <== NOT EXECUTED 10ec28: 6a 02 push $0x2 <== NOT EXECUTED 10ec2a: 68 20 ed 11 00 push $0x11ed20 <== NOT EXECUTED 10ec2f: e8 94 ce ff ff call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10ec34: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_MESSAGE_QUEUE, _Message_queue_MP_Process_packet ); #endif } 10ec37: c9 leave <== NOT EXECUTED 10ec38: c3 ret <== NOT EXECUTED 0010a11c <_Message_queue_Translate_core_message_queue_return_code>: }; rtems_status_code _Message_queue_Translate_core_message_queue_return_code ( uint32_t status ) { 10a11c: 55 push %ebp <== NOT EXECUTED 10a11d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a11f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a122: 8b 04 85 34 c8 11 00 mov 0x11c834(,%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]; } 10a129: c9 leave <== NOT EXECUTED 10a12a: c3 ret <== NOT EXECUTED 0010f454 <_Objects_API_maximum_class>: #include int _Objects_API_maximum_class( uint32_t api ) { 10f454: 55 push %ebp <== NOT EXECUTED 10f455: 89 e5 mov %esp,%ebp <== NOT EXECUTED switch (api) { 10f457: 83 7d 08 02 cmpl $0x2,0x8(%ebp) <== NOT EXECUTED 10f45b: 74 2f je 10f48c <_Objects_API_maximum_class+0x38> <== NOT EXECUTED 10f45d: 76 15 jbe 10f474 <_Objects_API_maximum_class+0x20> <== NOT EXECUTED 10f45f: 83 7d 08 03 cmpl $0x3,0x8(%ebp) <== NOT EXECUTED 10f463: 74 1f je 10f484 <_Objects_API_maximum_class+0x30> <== NOT EXECUTED 10f465: 83 7d 08 04 cmpl $0x4,0x8(%ebp) <== NOT EXECUTED 10f469: 75 0f jne 10f47a <_Objects_API_maximum_class+0x26> <== 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; 10f46b: b8 08 00 00 00 mov $0x8,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10f470: c9 leave <== NOT EXECUTED 10f471: c3 ret <== NOT EXECUTED 10f472: 66 90 xchg %ax,%ax <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10f474: 83 7d 08 01 cmpl $0x1,0x8(%ebp) <== NOT EXECUTED 10f478: 74 1a je 10f494 <_Objects_API_maximum_class+0x40> <== 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; 10f47a: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10f47f: c9 leave <== NOT EXECUTED 10f480: c3 ret <== NOT EXECUTED 10f481: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10f484: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10f489: c9 leave <== NOT EXECUTED 10f48a: c3 ret <== NOT EXECUTED 10f48b: 90 nop <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10f48c: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10f491: c9 leave <== NOT EXECUTED 10f492: c3 ret <== NOT EXECUTED 10f493: 90 nop <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10f494: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10f499: c9 leave <== NOT EXECUTED 10f49a: c3 ret <== NOT EXECUTED 0010b570 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10b570: 55 push %ebp <== NOT EXECUTED 10b571: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b573: 56 push %esi <== NOT EXECUTED 10b574: 53 push %ebx <== NOT EXECUTED 10b575: 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 ) 10b578: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10b57b: 85 c0 test %eax,%eax <== NOT EXECUTED 10b57d: 75 0d jne 10b58c <_Objects_Allocate+0x1c> <== NOT EXECUTED 10b57f: 31 c9 xor %ecx,%ecx <== NOT EXECUTED information->inactive--; } } return the_object; } 10b581: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b583: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b586: 5b pop %ebx <== NOT EXECUTED 10b587: 5e pop %esi <== NOT EXECUTED 10b588: c9 leave <== NOT EXECUTED 10b589: c3 ret <== NOT EXECUTED 10b58a: 66 90 xchg %ax,%ax <== 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 ); 10b58c: 8d 73 20 lea 0x20(%ebx),%esi <== NOT EXECUTED 10b58f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b592: 56 push %esi <== NOT EXECUTED 10b593: e8 c4 f7 ff ff call 10ad5c <_Chain_Get> <== NOT EXECUTED 10b598: 89 c1 mov %eax,%ecx <== NOT EXECUTED if ( information->auto_extend ) { 10b59a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b59d: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10b5a1: 74 de je 10b581 <_Objects_Allocate+0x11> <== NOT EXECUTED /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10b5a3: 85 c0 test %eax,%eax <== NOT EXECUTED 10b5a5: 74 2d je 10b5d4 <_Objects_Allocate+0x64> <== NOT EXECUTED } if ( the_object ) { uint32_t block; block = _Objects_Get_index( the_object->id ) - 10b5a7: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10b5aa: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10b5af: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10b5b2: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10b5b8: 29 d0 sub %edx,%eax <== NOT EXECUTED _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]--; 10b5ba: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b5bc: f7 73 14 divl 0x14(%ebx) <== NOT EXECUTED 10b5bf: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b5c2: 03 43 30 add 0x30(%ebx),%eax <== NOT EXECUTED 10b5c5: ff 08 decl (%eax) <== NOT EXECUTED information->inactive--; 10b5c7: 66 ff 4b 2c decw 0x2c(%ebx) <== NOT EXECUTED } } return the_object; } 10b5cb: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b5cd: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b5d0: 5b pop %ebx <== NOT EXECUTED 10b5d1: 5e pop %esi <== NOT EXECUTED 10b5d2: c9 leave <== NOT EXECUTED 10b5d3: c3 ret <== NOT EXECUTED * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { _Objects_Extend_information( information ); 10b5d4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b5d7: 53 push %ebx <== NOT EXECUTED 10b5d8: e8 37 00 00 00 call 10b614 <_Objects_Extend_information> <== NOT EXECUTED the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10b5dd: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10b5e0: e8 77 f7 ff ff call 10ad5c <_Chain_Get> <== NOT EXECUTED 10b5e5: 89 c1 mov %eax,%ecx <== NOT EXECUTED } if ( the_object ) { 10b5e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b5ea: 85 c0 test %eax,%eax <== NOT EXECUTED 10b5ec: 74 93 je 10b581 <_Objects_Allocate+0x11> <== NOT EXECUTED 10b5ee: eb b7 jmp 10b5a7 <_Objects_Allocate+0x37> <== NOT EXECUTED 0010b5f0 <_Objects_Close>: void _Objects_Close( Objects_Information *information, Objects_Control *the_object ) { 10b5f0: 55 push %ebp <== NOT EXECUTED 10b5f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b5f3: 53 push %ebx <== NOT EXECUTED 10b5f4: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b5f7: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10b5fa: 0f b7 51 08 movzwl 0x8(%ecx),%edx <== NOT EXECUTED 10b5fe: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10b601: 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 ); 10b608: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED } 10b60b: 5b pop %ebx <== NOT EXECUTED 10b60c: c9 leave <== NOT EXECUTED Objects_Control *the_object ) { _Objects_Invalidate_Id( information, the_object ); _Objects_Namespace_remove( information, the_object ); 10b60d: e9 76 05 00 00 jmp 10bb88 <_Objects_Namespace_remove> <== NOT EXECUTED 0010b614 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 10b614: 55 push %ebp <== NOT EXECUTED 10b615: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b617: 57 push %edi <== NOT EXECUTED 10b618: 56 push %esi <== NOT EXECUTED 10b619: 53 push %ebx <== NOT EXECUTED 10b61a: 83 ec 5c sub $0x5c,%esp <== 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 10b61d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b620: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10b623: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10b628: 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 ) 10b62b: 0f b7 72 10 movzwl 0x10(%edx),%esi <== NOT EXECUTED 10b62f: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10b631: 0f 83 e9 01 00 00 jae 10b820 <_Objects_Extend_information+0x20c> <== NOT EXECUTED 10b637: 8b 4a 14 mov 0x14(%edx),%ecx <== NOT EXECUTED 10b63a: 89 4d a8 mov %ecx,-0x58(%ebp) <== NOT EXECUTED 10b63d: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED 10b640: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp) <== NOT EXECUTED 10b647: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b649: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) <== NOT EXECUTED 10b650: ba 03 00 00 00 mov $0x3,%edx <== NOT EXECUTED * Up the block count and maximum */ block_count++; maximum = information->maximum + information->allocation_size; 10b655: 03 75 a8 add -0x58(%ebp),%esi <== NOT EXECUTED 10b658: 89 75 d4 mov %esi,-0x2c(%ebp) <== NOT EXECUTED /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 10b65b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b65e: 80 78 12 00 cmpb $0x0,0x12(%eax) <== NOT EXECUTED 10b662: 0f 85 1c 02 00 00 jne 10b884 <_Objects_Extend_information+0x270> <== NOT EXECUTED if ( !object_blocks ) return; } else { object_blocks = (void**) 10b668: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b66b: 8b 75 c8 mov -0x38(%ebp),%esi <== NOT EXECUTED 10b66e: 8d 04 32 lea (%edx,%esi,1),%eax <== NOT EXECUTED 10b671: 03 45 d4 add -0x2c(%ebp),%eax <== NOT EXECUTED 10b674: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b677: 50 push %eax <== NOT EXECUTED 10b678: e8 77 1d 00 00 call 10d3f4 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10b67d: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED 10b680: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 10b683: 8b 7d e0 mov -0x20(%ebp),%edi <== NOT EXECUTED 10b686: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10b689: 8d 3c b8 lea (%eax,%edi,4),%edi <== NOT EXECUTED 10b68c: 89 7d d0 mov %edi,-0x30(%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 10b68f: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 10b692: 8d 14 d0 lea (%eax,%edx,8),%edx <== NOT EXECUTED 10b695: 89 55 d8 mov %edx,-0x28(%ebp) <== NOT EXECUTED * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 10b698: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b69b: 0f b7 41 10 movzwl 0x10(%ecx),%eax <== NOT EXECUTED 10b69f: 3b 45 c8 cmp -0x38(%ebp),%eax <== NOT EXECUTED 10b6a2: 0f 87 38 02 00 00 ja 10b8e0 <_Objects_Extend_information+0x2cc> <== NOT EXECUTED else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10b6a8: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 10b6ab: 85 c0 test %eax,%eax <== NOT EXECUTED 10b6ad: 74 15 je 10b6c4 <_Objects_Extend_information+0xb0> <== NOT EXECUTED information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 10b6af: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b6b1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { local_table[ index ] = NULL; 10b6b4: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 10b6b7: c7 04 82 00 00 00 00 movl $0x0,(%edx,%eax,4) <== NOT EXECUTED else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10b6be: 40 inc %eax <== NOT EXECUTED 10b6bf: 3b 45 c8 cmp -0x38(%ebp),%eax <== NOT EXECUTED 10b6c2: 72 f0 jb 10b6b4 <_Objects_Extend_information+0xa0> <== NOT EXECUTED /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 10b6c4: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 10b6c7: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b6ca: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED 10b6cd: c7 04 01 00 00 00 00 movl $0x0,(%ecx,%eax,1) <== NOT EXECUTED inactive_per_block[block_count] = 0; 10b6d4: 8b 75 d0 mov -0x30(%ebp),%esi <== NOT EXECUTED 10b6d7: c7 04 06 00 00 00 00 movl $0x0,(%esi,%eax,1) <== NOT EXECUTED for ( index=index_base ; index < ( information->allocation_size + index_base ); 10b6de: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED 10b6e1: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b6e4: 03 4f 14 add 0x14(%edi),%ecx <== NOT EXECUTED 10b6e7: 3b 4d c4 cmp -0x3c(%ebp),%ecx <== NOT EXECUTED 10b6ea: 76 1a jbe 10b706 <_Objects_Extend_information+0xf2> <== NOT EXECUTED 10b6ec: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED 10b6ef: 8b 75 d8 mov -0x28(%ebp),%esi <== NOT EXECUTED 10b6f2: 8d 14 86 lea (%esi,%eax,4),%edx <== NOT EXECUTED 10b6f5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED index++ ) { local_table[ index ] = NULL; 10b6f8: 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++ ) { 10b6fe: 40 inc %eax <== NOT EXECUTED 10b6ff: 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 ); 10b702: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10b704: 77 f2 ja 10b6f8 <_Objects_Extend_information+0xe4> <== NOT EXECUTED index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 10b706: 9c pushf <== NOT EXECUTED 10b707: fa cli <== NOT EXECUTED 10b708: 59 pop %ecx <== NOT EXECUTED old_tables = information->object_blocks; 10b709: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b70c: 8b 77 34 mov 0x34(%edi),%esi <== NOT EXECUTED information->object_blocks = object_blocks; 10b70f: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10b712: 89 47 34 mov %eax,0x34(%edi) <== NOT EXECUTED information->inactive_per_block = inactive_per_block; 10b715: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 10b718: 89 57 30 mov %edx,0x30(%edi) <== NOT EXECUTED information->local_table = local_table; 10b71b: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 10b71e: 89 47 1c mov %eax,0x1c(%edi) <== NOT EXECUTED information->maximum = maximum; 10b721: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 10b724: 66 89 57 10 mov %dx,0x10(%edi) <== NOT EXECUTED information->maximum_id = _Objects_Build_id( 10b728: 8b 17 mov (%edi),%edx <== NOT EXECUTED 10b72a: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10b72d: 81 ca 00 00 01 00 or $0x10000,%edx <== NOT EXECUTED 10b733: 0f b7 47 04 movzwl 0x4(%edi),%eax <== NOT EXECUTED 10b737: c1 e0 1b shl $0x1b,%eax <== NOT EXECUTED 10b73a: 09 c2 or %eax,%edx <== NOT EXECUTED 10b73c: 0f b7 45 d4 movzwl -0x2c(%ebp),%eax <== NOT EXECUTED 10b740: 09 c2 or %eax,%edx <== NOT EXECUTED 10b742: 89 57 0c mov %edx,0xc(%edi) <== NOT EXECUTED information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 10b745: 51 push %ecx <== NOT EXECUTED 10b746: 9d popf <== NOT EXECUTED if ( old_tables ) 10b747: 85 f6 test %esi,%esi <== NOT EXECUTED 10b749: 0f 84 c9 01 00 00 je 10b918 <_Objects_Extend_information+0x304> <== NOT EXECUTED _Workspace_Free( old_tables ); 10b74f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b752: 56 push %esi <== NOT EXECUTED 10b753: e8 6c 1c 00 00 call 10d3c4 <_Workspace_Free> <== NOT EXECUTED 10b758: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10b75b: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED 10b75e: 89 75 a8 mov %esi,-0x58(%ebp) <== NOT EXECUTED 10b761: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 10b764: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b767: 80 7f 12 00 cmpb $0x0,0x12(%edi) <== NOT EXECUTED 10b76b: 0f 84 3b 01 00 00 je 10b8ac <_Objects_Extend_information+0x298> <== NOT EXECUTED information->object_blocks[ block ] = 10b771: c1 e3 02 shl $0x2,%ebx <== NOT EXECUTED 10b774: 89 5d dc mov %ebx,-0x24(%ebp) <== NOT EXECUTED 10b777: 03 5f 34 add 0x34(%edi),%ebx <== NOT EXECUTED 10b77a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b77d: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED 10b780: 0f af 47 18 imul 0x18(%edi),%eax <== NOT EXECUTED 10b784: 50 push %eax <== NOT EXECUTED 10b785: e8 52 1c 00 00 call 10d3dc <_Workspace_Allocate> <== NOT EXECUTED 10b78a: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Workspace_Allocate( (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 10b78c: 8b 47 34 mov 0x34(%edi),%eax <== NOT EXECUTED 10b78f: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 10b792: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10b795: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b798: 85 c0 test %eax,%eax <== NOT EXECUTED 10b79a: 74 7a je 10b816 <_Objects_Extend_information+0x202> <== NOT EXECUTED /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 10b79c: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b79f: ff 71 18 pushl 0x18(%ecx) <== NOT EXECUTED 10b7a2: ff 71 14 pushl 0x14(%ecx) <== NOT EXECUTED 10b7a5: 50 push %eax <== NOT EXECUTED 10b7a6: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 10b7a9: 56 push %esi <== NOT EXECUTED 10b7aa: e8 45 38 00 00 call 10eff4 <_Chain_Initialize> <== NOT EXECUTED information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10b7af: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10b7b2: 83 c6 20 add $0x20,%esi <== NOT EXECUTED 10b7b5: 8b 5d c4 mov -0x3c(%ebp),%ebx <== NOT EXECUTED 10b7b8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b7bb: eb 2c jmp 10b7e9 <_Objects_Extend_information+0x1d5> <== NOT EXECUTED 10b7bd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 10b7c0: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b7c3: 8b 07 mov (%edi),%eax <== NOT EXECUTED 10b7c5: c1 e0 18 shl $0x18,%eax <== NOT EXECUTED 10b7c8: 0d 00 00 01 00 or $0x10000,%eax <== NOT EXECUTED 10b7cd: 0f b7 57 04 movzwl 0x4(%edi),%edx <== NOT EXECUTED 10b7d1: c1 e2 1b shl $0x1b,%edx <== NOT EXECUTED 10b7d4: 09 d0 or %edx,%eax <== NOT EXECUTED 10b7d6: 09 d8 or %ebx,%eax <== NOT EXECUTED 10b7d8: 89 41 08 mov %eax,0x8(%ecx) <== NOT EXECUTED information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10b7db: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b7de: 51 push %ecx <== NOT EXECUTED 10b7df: 56 push %esi <== NOT EXECUTED 10b7e0: e8 53 f5 ff ff call 10ad38 <_Chain_Append> <== NOT EXECUTED index++; 10b7e5: 43 inc %ebx <== NOT EXECUTED 10b7e6: 83 c4 10 add $0x10,%esp <== 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 ) { 10b7e9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b7ec: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10b7ef: 50 push %eax <== NOT EXECUTED 10b7f0: e8 67 f5 ff ff call 10ad5c <_Chain_Get> <== NOT EXECUTED 10b7f5: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b7f7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b7fa: 85 c0 test %eax,%eax <== NOT EXECUTED 10b7fc: 75 c2 jne 10b7c0 <_Objects_Extend_information+0x1ac> <== NOT EXECUTED _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 10b7fe: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b801: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10b804: 89 d1 mov %edx,%ecx <== NOT EXECUTED 10b806: 8b 52 14 mov 0x14(%edx),%edx <== NOT EXECUTED 10b809: 8b 75 dc mov -0x24(%ebp),%esi <== NOT EXECUTED 10b80c: 89 14 30 mov %edx,(%eax,%esi,1) <== NOT EXECUTED information->inactive += information->allocation_size; 10b80f: 8b 41 14 mov 0x14(%ecx),%eax <== NOT EXECUTED 10b812: 66 01 41 2c add %ax,0x2c(%ecx) <== NOT EXECUTED } 10b816: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b819: 5b pop %ebx <== NOT EXECUTED 10b81a: 5e pop %esi <== NOT EXECUTED 10b81b: 5f pop %edi <== NOT EXECUTED 10b81c: c9 leave <== NOT EXECUTED 10b81d: c3 ret <== NOT EXECUTED 10b81e: 66 90 xchg %ax,%ax <== NOT EXECUTED block = 0; if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; 10b820: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b823: 8b 7f 14 mov 0x14(%edi),%edi <== NOT EXECUTED 10b826: 89 7d a8 mov %edi,-0x58(%ebp) <== NOT EXECUTED 10b829: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b82b: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b82d: f7 f7 div %edi <== NOT EXECUTED 10b82f: 89 45 a4 mov %eax,-0x5c(%ebp) <== NOT EXECUTED 10b832: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED for ( ; block < block_count; block++ ) { 10b835: 85 c0 test %eax,%eax <== NOT EXECUTED 10b837: 0f 84 e6 00 00 00 je 10b923 <_Objects_Extend_information+0x30f> <== NOT EXECUTED if ( information->object_blocks[ block ] == NULL ) 10b83d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b840: 8b 4f 34 mov 0x34(%edi),%ecx <== NOT EXECUTED 10b843: 8b 19 mov (%ecx),%ebx <== NOT EXECUTED 10b845: 85 db test %ebx,%ebx <== NOT EXECUTED 10b847: 0f 84 d6 00 00 00 je 10b923 <_Objects_Extend_information+0x30f> <== NOT EXECUTED 10b84d: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 10b850: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED 10b853: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b855: eb 08 jmp 10b85f <_Objects_Extend_information+0x24b> <== NOT EXECUTED 10b857: 90 nop <== NOT EXECUTED 10b858: 8b 14 99 mov (%ecx,%ebx,4),%edx <== NOT EXECUTED 10b85b: 85 d2 test %edx,%edx <== NOT EXECUTED 10b85d: 74 0c je 10b86b <_Objects_Extend_information+0x257> <== NOT EXECUTED break; else index_base += information->allocation_size; 10b85f: 8b 55 a8 mov -0x58(%ebp),%edx <== NOT EXECUTED 10b862: 01 55 c4 add %edx,-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++ ) { 10b865: 43 inc %ebx <== NOT EXECUTED 10b866: 39 5d a4 cmp %ebx,-0x5c(%ebp) <== NOT EXECUTED 10b869: 77 ed ja 10b858 <_Objects_Extend_information+0x244> <== NOT EXECUTED /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 10b86b: 39 75 c4 cmp %esi,-0x3c(%ebp) <== NOT EXECUTED 10b86e: 0f 82 f0 fe ff ff jb 10b764 <_Objects_Extend_information+0x150> <== NOT EXECUTED 10b874: 8b 7d a4 mov -0x5c(%ebp),%edi <== NOT EXECUTED 10b877: 47 inc %edi <== NOT EXECUTED 10b878: 89 7d e0 mov %edi,-0x20(%ebp) <== NOT EXECUTED 10b87b: 8d 14 7f lea (%edi,%edi,2),%edx <== NOT EXECUTED 10b87e: e9 d2 fd ff ff jmp 10b655 <_Objects_Extend_information+0x41> <== NOT EXECUTED 10b883: 90 nop <== NOT EXECUTED /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { object_blocks = (void**) 10b884: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b887: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED 10b88a: 8d 04 0a lea (%edx,%ecx,1),%eax <== NOT EXECUTED 10b88d: 01 f0 add %esi,%eax <== NOT EXECUTED 10b88f: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b892: 50 push %eax <== NOT EXECUTED 10b893: e8 44 1b 00 00 call 10d3dc <_Workspace_Allocate> <== NOT EXECUTED 10b898: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)) ); if ( !object_blocks ) 10b89b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b89e: 85 c0 test %eax,%eax <== NOT EXECUTED 10b8a0: 0f 85 dd fd ff ff jne 10b683 <_Objects_Extend_information+0x6f> <== NOT EXECUTED 10b8a6: e9 6b ff ff ff jmp 10b816 <_Objects_Extend_information+0x202> <== NOT EXECUTED 10b8ab: 90 nop <== NOT EXECUTED if ( !information->object_blocks[ block ] ) return; } else { information->object_blocks[ block ] = 10b8ac: c1 e3 02 shl $0x2,%ebx <== NOT EXECUTED 10b8af: 89 5d dc mov %ebx,-0x24(%ebp) <== NOT EXECUTED 10b8b2: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b8b5: 03 59 34 add 0x34(%ecx),%ebx <== NOT EXECUTED 10b8b8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b8bb: 8b 75 a8 mov -0x58(%ebp),%esi <== NOT EXECUTED 10b8be: 0f af 71 18 imul 0x18(%ecx),%esi <== NOT EXECUTED 10b8c2: 56 push %esi <== NOT EXECUTED 10b8c3: e8 2c 1b 00 00 call 10d3f4 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10b8c8: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10b8ca: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b8cd: 8b 47 34 mov 0x34(%edi),%eax <== NOT EXECUTED 10b8d0: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 10b8d3: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10b8d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b8d9: e9 be fe ff ff jmp 10b79c <_Objects_Extend_information+0x188> <== NOT EXECUTED 10b8de: 66 90 xchg %ax,%ax <== 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, 10b8e0: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 10b8e3: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b8e6: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b8e9: 8b 77 34 mov 0x34(%edi),%esi <== NOT EXECUTED 10b8ec: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED 10b8ef: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b8f1: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 10b8f3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b8f6: 8b 72 30 mov 0x30(%edx),%esi <== NOT EXECUTED 10b8f9: 8b 7d d0 mov -0x30(%ebp),%edi <== NOT EXECUTED 10b8fc: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b8fe: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 10b900: 0f b7 4a 10 movzwl 0x10(%edx),%ecx <== NOT EXECUTED 10b904: 03 4d c8 add -0x38(%ebp),%ecx <== NOT EXECUTED 10b907: c1 e1 02 shl $0x2,%ecx <== NOT EXECUTED 10b90a: 8b 72 1c mov 0x1c(%edx),%esi <== NOT EXECUTED 10b90d: 8b 7d d8 mov -0x28(%ebp),%edi <== NOT EXECUTED 10b910: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10b912: e9 ad fd ff ff jmp 10b6c4 <_Objects_Extend_information+0xb0> <== NOT EXECUTED 10b917: 90 nop <== NOT EXECUTED information->maximum ); _ISR_Enable( level ); if ( old_tables ) 10b918: 8b 4f 14 mov 0x14(%edi),%ecx <== NOT EXECUTED 10b91b: 89 4d a8 mov %ecx,-0x58(%ebp) <== NOT EXECUTED 10b91e: e9 41 fe ff ff jmp 10b764 <_Objects_Extend_information+0x150> <== NOT EXECUTED if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10b923: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED 10b926: 89 4d c4 mov %ecx,-0x3c(%ebp) <== NOT EXECUTED 10b929: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b92b: e9 3b ff ff ff jmp 10b86b <_Objects_Extend_information+0x257> <== NOT EXECUTED 0010b930 <_Objects_Free>: void _Objects_Free( Objects_Information *information, Objects_Control *the_object ) { 10b930: 55 push %ebp <== NOT EXECUTED 10b931: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b933: 57 push %edi <== NOT EXECUTED 10b934: 56 push %esi <== NOT EXECUTED 10b935: 53 push %ebx <== NOT EXECUTED 10b936: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10b939: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b93c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED uint32_t allocation_size = information->allocation_size; 10b93f: 8b 7b 14 mov 0x14(%ebx),%edi <== NOT EXECUTED _Chain_Append( &information->Inactive, &the_object->Node ); 10b942: 56 push %esi <== NOT EXECUTED 10b943: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED 10b946: 50 push %eax <== NOT EXECUTED 10b947: e8 ec f3 ff ff call 10ad38 <_Chain_Append> <== NOT EXECUTED if ( information->auto_extend ) { 10b94c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b94f: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10b953: 74 35 je 10b98a <_Objects_Free+0x5a> <== NOT EXECUTED uint32_t block; block = 10b955: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10b958: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10b95d: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10b960: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10b966: 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 ]++; 10b968: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b96a: f7 73 14 divl 0x14(%ebx) <== NOT EXECUTED 10b96d: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b970: 03 43 30 add 0x30(%ebx),%eax <== NOT EXECUTED 10b973: ff 00 incl (%eax) <== NOT EXECUTED information->inactive++; 10b975: 8b 53 2c mov 0x2c(%ebx),%edx <== NOT EXECUTED 10b978: 42 inc %edx <== NOT EXECUTED 10b979: 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 ) ) ) { 10b97d: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10b980: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b982: d1 e8 shr %eax <== NOT EXECUTED 10b984: 01 f8 add %edi,%eax <== NOT EXECUTED 10b986: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10b988: 77 0a ja 10b994 <_Objects_Free+0x64> <== NOT EXECUTED _Objects_Shrink_information( information ); } } } 10b98a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b98d: 5b pop %ebx <== NOT EXECUTED 10b98e: 5e pop %esi <== NOT EXECUTED 10b98f: 5f pop %edi <== NOT EXECUTED 10b990: c9 leave <== NOT EXECUTED 10b991: c3 ret <== NOT EXECUTED 10b992: 66 90 xchg %ax,%ax <== 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 ); 10b994: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } } 10b997: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b99a: 5b pop %ebx <== NOT EXECUTED 10b99b: 5e pop %esi <== NOT EXECUTED 10b99c: 5f pop %edi <== NOT EXECUTED 10b99d: 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 ); 10b99e: e9 a5 02 00 00 jmp 10bc48 <_Objects_Shrink_information> <== NOT EXECUTED 0010ba64 <_Objects_Get>: Objects_Control *_Objects_Get( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 10ba64: 55 push %ebp <== NOT EXECUTED 10ba65: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ba67: 53 push %ebx <== NOT EXECUTED 10ba68: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10ba6b: 8b 4d 08 mov 0x8(%ebp),%ecx <== 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; 10ba6e: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10ba73: 2b 51 08 sub 0x8(%ecx),%edx <== NOT EXECUTED 10ba76: 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 ) { 10ba79: 0f b7 41 10 movzwl 0x10(%ecx),%eax <== NOT EXECUTED 10ba7d: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10ba7f: 77 27 ja 10baa8 <_Objects_Get+0x44> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10ba81: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10ba86: 40 inc %eax <== NOT EXECUTED 10ba87: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED _Thread_Disable_dispatch(); if ( (the_object = information->local_table[ index ]) != NULL ) { 10ba8c: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 10ba8f: 8b 1c 90 mov (%eax,%edx,4),%ebx <== NOT EXECUTED 10ba92: 85 db test %ebx,%ebx <== NOT EXECUTED 10ba94: 74 1f je 10bab5 <_Objects_Get+0x51> <== NOT EXECUTED *location = OBJECTS_LOCAL; 10ba96: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10ba99: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 10ba9f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10baa1: 5a pop %edx <== NOT EXECUTED 10baa2: 5b pop %ebx <== NOT EXECUTED 10baa3: c9 leave <== NOT EXECUTED 10baa4: c3 ret <== NOT EXECUTED 10baa5: 8d 76 00 lea 0x0(%esi),%esi <== 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; 10baa8: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10baab: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10bab1: 31 db xor %ebx,%ebx <== NOT EXECUTED 10bab3: eb ea jmp 10ba9f <_Objects_Get+0x3b> <== NOT EXECUTED /* * Valid Id for this API, Class and Node but the object has not * been allocated yet. */ _Thread_Enable_dispatch(); 10bab5: e8 ee 07 00 00 call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED *location = OBJECTS_ERROR; 10baba: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10babd: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10bac3: eb da jmp 10ba9f <_Objects_Get+0x3b> <== NOT EXECUTED 0010b9c4 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint32_t the_class ) { 10b9c4: 55 push %ebp <== NOT EXECUTED 10b9c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b9c7: 53 push %ebx <== NOT EXECUTED 10b9c8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b9cb: 8b 5d 08 mov 0x8(%ebp),%ebx <== 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. 10b9ce: 8d 43 ff lea -0x1(%ebx),%eax <== NOT EXECUTED 10b9d1: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b9d4: 77 07 ja 10b9dd <_Objects_Get_information+0x19> <== NOT EXECUTED int the_class_api_maximum; if ( !_Objects_Is_api_valid( the_api ) ) return NULL; if ( !the_class ) 10b9d6: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b9d9: 85 c0 test %eax,%eax <== NOT EXECUTED 10b9db: 75 07 jne 10b9e4 <_Objects_Get_information+0x20> <== 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 ) 10b9dd: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; #endif return info; } 10b9df: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b9e2: c9 leave <== NOT EXECUTED 10b9e3: c3 ret <== NOT EXECUTED return NULL; if ( !the_class ) return NULL; the_class_api_maximum = _Objects_API_maximum_class( the_api ); 10b9e4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b9e7: 53 push %ebx <== NOT EXECUTED 10b9e8: e8 67 3a 00 00 call 10f454 <_Objects_API_maximum_class> <== NOT EXECUTED if ( the_class_api_maximum < 0 || 10b9ed: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b9f0: 85 c0 test %eax,%eax <== NOT EXECUTED 10b9f2: 78 e9 js 10b9dd <_Objects_Get_information+0x19> <== NOT EXECUTED 10b9f4: 39 45 0c cmp %eax,0xc(%ebp) <== NOT EXECUTED 10b9f7: 77 e4 ja 10b9dd <_Objects_Get_information+0x19> <== NOT EXECUTED the_class > (uint32_t) the_class_api_maximum ) return NULL; if ( !_Objects_Information_table[ the_api ] ) 10b9f9: 8b 04 9d cc e9 11 00 mov 0x11e9cc(,%ebx,4),%eax <== NOT EXECUTED 10ba00: 85 c0 test %eax,%eax <== NOT EXECUTED 10ba02: 74 d9 je 10b9dd <_Objects_Get_information+0x19> <== NOT EXECUTED return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10ba04: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10ba07: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED if ( !info ) 10ba0a: 85 c0 test %eax,%eax <== NOT EXECUTED 10ba0c: 74 d1 je 10b9df <_Objects_Get_information+0x1b> <== 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 ) 10ba0e: 66 83 78 10 00 cmpw $0x0,0x10(%eax) <== NOT EXECUTED 10ba13: 75 ca jne 10b9df <_Objects_Get_information+0x1b> <== NOT EXECUTED 10ba15: eb c6 jmp 10b9dd <_Objects_Get_information+0x19> <== NOT EXECUTED 0010b9a4 <_Objects_Get_information_id>: #include Objects_Information *_Objects_Get_information_id( Objects_Id id ) { 10b9a4: 55 push %ebp <== NOT EXECUTED 10b9a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b9a7: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10b9aa: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED return _Objects_Get_information( 10b9ad: 89 c2 mov %eax,%edx <== NOT EXECUTED 10b9af: c1 ea 1b shr $0x1b,%edx <== NOT EXECUTED 10b9b2: 52 push %edx <== NOT EXECUTED 10b9b3: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10b9b6: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 10b9b9: 50 push %eax <== NOT EXECUTED 10b9ba: e8 05 00 00 00 call 10b9c4 <_Objects_Get_information> <== NOT EXECUTED _Objects_Get_API( id ), _Objects_Get_class( id ) ); } 10b9bf: c9 leave <== NOT EXECUTED 10b9c0: c3 ret <== NOT EXECUTED 0010ba18 <_Objects_Get_isr_disable>: Objects_Information *information, Objects_Id id, Objects_Locations *location, ISR_Level *level_p ) { 10ba18: 55 push %ebp <== NOT EXECUTED 10ba19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ba1b: 56 push %esi <== NOT EXECUTED 10ba1c: 53 push %ebx <== NOT EXECUTED 10ba1d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10ba20: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) index = id - information->minimum_id + 1; #else /* index = _Objects_Get_index( id ); */ index = id & 0x0000ffff; 10ba23: 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 ); 10ba27: 9c pushf <== NOT EXECUTED 10ba28: fa cli <== NOT EXECUTED 10ba29: 59 pop %ecx <== NOT EXECUTED if ( information->maximum >= index ) { 10ba2a: 0f b7 43 10 movzwl 0x10(%ebx),%eax <== NOT EXECUTED 10ba2e: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10ba30: 77 1a ja 10ba4c <_Objects_Get_isr_disable+0x34> <== NOT EXECUTED if ( (the_object = information->local_table[ index ]) != NULL ) { 10ba32: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10ba35: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED 10ba38: 85 c0 test %eax,%eax <== NOT EXECUTED 10ba3a: 74 1c je 10ba58 <_Objects_Get_isr_disable+0x40> <== NOT EXECUTED *location = OBJECTS_LOCAL; 10ba3c: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED *level_p = level; 10ba42: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10ba45: 89 0a mov %ecx,(%edx) <== NOT EXECUTED _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 10ba47: 5b pop %ebx <== NOT EXECUTED 10ba48: 5e pop %esi <== NOT EXECUTED 10ba49: c9 leave <== NOT EXECUTED 10ba4a: c3 ret <== NOT EXECUTED 10ba4b: 90 nop <== NOT EXECUTED } _ISR_Enable( level ); *location = OBJECTS_ERROR; return NULL; } _ISR_Enable( level ); 10ba4c: 51 push %ecx <== NOT EXECUTED 10ba4d: 9d popf <== NOT EXECUTED *location = OBJECTS_ERROR; 10ba4e: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 10ba54: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ba56: eb ef jmp 10ba47 <_Objects_Get_isr_disable+0x2f> <== NOT EXECUTED if ( (the_object = information->local_table[ index ]) != NULL ) { *location = OBJECTS_LOCAL; *level_p = level; return the_object; } _ISR_Enable( level ); 10ba58: 51 push %ecx <== NOT EXECUTED 10ba59: 9d popf <== NOT EXECUTED *location = OBJECTS_ERROR; 10ba5a: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 10ba60: eb e5 jmp 10ba47 <_Objects_Get_isr_disable+0x2f> <== NOT EXECUTED 001163f8 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 1163f8: 55 push %ebp <== NOT EXECUTED 1163f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1163fb: 57 push %edi <== NOT EXECUTED 1163fc: 56 push %esi <== NOT EXECUTED 1163fd: 53 push %ebx <== NOT EXECUTED 1163fe: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 116401: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 116404: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED char lname[5]; Objects_Control *the_object; Objects_Locations location; Objects_Id tmpId; if ( length == 0 ) 116407: 85 f6 test %esi,%esi <== NOT EXECUTED 116409: 75 0d jne 116418 <_Objects_Get_name_as_string+0x20> <== NOT EXECUTED } } *d = '\0'; _Thread_Enable_dispatch(); return name; 11640b: 31 db xor %ebx,%ebx <== NOT EXECUTED } return NULL; /* unreachable path */ } 11640d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11640f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116412: 5b pop %ebx <== NOT EXECUTED 116413: 5e pop %esi <== NOT EXECUTED 116414: 5f pop %edi <== NOT EXECUTED 116415: c9 leave <== NOT EXECUTED 116416: c3 ret <== NOT EXECUTED 116417: 90 nop <== NOT EXECUTED Objects_Id tmpId; if ( length == 0 ) return NULL; if ( name == NULL ) 116418: 85 db test %ebx,%ebx <== NOT EXECUTED 11641a: 74 f1 je 11640d <_Objects_Get_name_as_string+0x15> <== NOT EXECUTED return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 11641c: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 11641f: 85 ff test %edi,%edi <== NOT EXECUTED 116421: 0f 84 8d 00 00 00 je 1164b4 <_Objects_Get_name_as_string+0xbc> <== NOT EXECUTED 116427: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11642a: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 11642d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 116430: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 116433: e8 78 a3 ff ff call 1107b0 <_Objects_Get_information_id> <== NOT EXECUTED 116438: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( !information ) 11643a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11643d: 85 c0 test %eax,%eax <== NOT EXECUTED 11643f: 74 ca je 11640b <_Objects_Get_name_as_string+0x13> <== NOT EXECUTED return NULL; the_object = _Objects_Get( information, tmpId, &location ); 116441: 51 push %ecx <== NOT EXECUTED 116442: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 116445: 50 push %eax <== NOT EXECUTED 116446: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 116449: 57 push %edi <== NOT EXECUTED 11644a: e8 21 a4 ff ff call 110870 <_Objects_Get> <== NOT EXECUTED switch ( location ) { 11644f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116452: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 116455: 85 d2 test %edx,%edx <== NOT EXECUTED 116457: 75 b2 jne 11640b <_Objects_Get_name_as_string+0x13> <== NOT EXECUTED case OBJECTS_ERROR: return NULL; case OBJECTS_LOCAL: if ( information->is_string ) { 116459: 80 7f 38 00 cmpb $0x0,0x38(%edi) <== NOT EXECUTED 11645d: 74 65 je 1164c4 <_Objects_Get_name_as_string+0xcc> <== NOT EXECUTED s = the_object->name.name_p; 11645f: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 116462: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED lname[ 4 ] = '\0'; s = lname; } d = name; if ( s ) { 116465: 85 c0 test %eax,%eax <== NOT EXECUTED 116467: 0f 84 84 00 00 00 je 1164f1 <_Objects_Get_name_as_string+0xf9> <== NOT EXECUTED for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 11646d: 4e dec %esi <== NOT EXECUTED 11646e: 89 75 d8 mov %esi,-0x28(%ebp) <== NOT EXECUTED 116471: 74 7e je 1164f1 <_Objects_Get_name_as_string+0xf9> <== NOT EXECUTED 116473: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 116476: 8a 08 mov (%eax),%cl <== NOT EXECUTED 116478: 84 c9 test %cl,%cl <== NOT EXECUTED 11647a: 74 75 je 1164f1 <_Objects_Get_name_as_string+0xf9> <== NOT EXECUTED 11647c: 89 df mov %ebx,%edi <== NOT EXECUTED 11647e: 31 f6 xor %esi,%esi <== NOT EXECUTED 116480: eb 0c jmp 11648e <_Objects_Get_name_as_string+0x96> <== NOT EXECUTED 116482: 66 90 xchg %ax,%ax <== NOT EXECUTED 116484: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 116487: 8a 0c 30 mov (%eax,%esi,1),%cl <== NOT EXECUTED 11648a: 84 c9 test %cl,%cl <== NOT EXECUTED 11648c: 74 19 je 1164a7 <_Objects_Get_name_as_string+0xaf> <== NOT EXECUTED *d = (isprint(*s)) ? *s : '*'; 11648e: 0f be d1 movsbl %cl,%edx <== NOT EXECUTED 116491: a1 88 a1 12 00 mov 0x12a188,%eax <== NOT EXECUTED 116496: f6 04 10 97 testb $0x97,(%eax,%edx,1) <== NOT EXECUTED 11649a: 75 02 jne 11649e <_Objects_Get_name_as_string+0xa6> <== NOT EXECUTED 11649c: b1 2a mov $0x2a,%cl <== NOT EXECUTED 11649e: 88 0f mov %cl,(%edi) <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 1164a0: 46 inc %esi <== NOT EXECUTED 1164a1: 47 inc %edi <== NOT EXECUTED 1164a2: 3b 75 d8 cmp -0x28(%ebp),%esi <== NOT EXECUTED 1164a5: 72 dd jb 116484 <_Objects_Get_name_as_string+0x8c> <== NOT EXECUTED *d = (isprint(*s)) ? *s : '*'; } } *d = '\0'; 1164a7: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 1164aa: e8 05 ac ff ff call 1110b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 1164af: e9 59 ff ff ff jmp 11640d <_Objects_Get_name_as_string+0x15> <== NOT EXECUTED return NULL; if ( name == NULL ) return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 1164b4: a1 9c ca 12 00 mov 0x12ca9c,%eax <== NOT EXECUTED 1164b9: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 1164bc: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 1164bf: e9 69 ff ff ff jmp 11642d <_Objects_Get_name_as_string+0x35> <== 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; 1164c4: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED lname[ 0 ] = (u32_name >> 24) & 0xff; 1164c7: 89 d0 mov %edx,%eax <== NOT EXECUTED 1164c9: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 1164cc: 88 45 eb mov %al,-0x15(%ebp) <== NOT EXECUTED lname[ 1 ] = (u32_name >> 16) & 0xff; 1164cf: 89 d0 mov %edx,%eax <== NOT EXECUTED 1164d1: c1 e8 10 shr $0x10,%eax <== NOT EXECUTED 1164d4: 88 45 ec mov %al,-0x14(%ebp) <== NOT EXECUTED lname[ 2 ] = (u32_name >> 8) & 0xff; 1164d7: 89 d0 mov %edx,%eax <== NOT EXECUTED 1164d9: c1 e8 08 shr $0x8,%eax <== NOT EXECUTED 1164dc: 88 45 ed mov %al,-0x13(%ebp) <== NOT EXECUTED lname[ 3 ] = (u32_name >> 0) & 0xff; 1164df: 88 55 ee mov %dl,-0x12(%ebp) <== NOT EXECUTED lname[ 4 ] = '\0'; 1164e2: c6 45 ef 00 movb $0x0,-0x11(%ebp) <== NOT EXECUTED 1164e6: 8d 45 eb lea -0x15(%ebp),%eax <== NOT EXECUTED 1164e9: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED 1164ec: e9 7c ff ff ff jmp 11646d <_Objects_Get_name_as_string+0x75> <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 1164f1: 89 df mov %ebx,%edi <== NOT EXECUTED 1164f3: eb b2 jmp 1164a7 <_Objects_Get_name_as_string+0xaf> <== NOT EXECUTED 001189ec <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 1189ec: 55 push %ebp <== NOT EXECUTED 1189ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1189ef: 57 push %edi <== NOT EXECUTED 1189f0: 56 push %esi <== NOT EXECUTED 1189f1: 53 push %ebx <== NOT EXECUTED 1189f2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1189f5: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 1189f8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1189fb: 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) 1189fe: 66 85 c0 test %ax,%ax <== NOT EXECUTED 118a01: 74 2d je 118a30 <_Objects_Get_next+0x44> <== NOT EXECUTED 118a03: 89 c3 mov %eax,%ebx <== NOT EXECUTED 118a05: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 118a08: 66 39 5f 10 cmp %bx,0x10(%edi) <== NOT EXECUTED 118a0c: 72 2e jb 118a3c <_Objects_Get_next+0x50> <== NOT EXECUTED *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 118a0e: 51 push %ecx <== NOT EXECUTED 118a0f: 56 push %esi <== NOT EXECUTED 118a10: 53 push %ebx <== NOT EXECUTED 118a11: 57 push %edi <== NOT EXECUTED 118a12: e8 59 7e ff ff call 110870 <_Objects_Get> <== NOT EXECUTED next_id++; 118a17: 43 inc %ebx <== NOT EXECUTED } while (*location_p != OBJECTS_LOCAL); 118a18: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 118a1b: 8b 16 mov (%esi),%edx <== NOT EXECUTED 118a1d: 85 d2 test %edx,%edx <== NOT EXECUTED 118a1f: 75 e7 jne 118a08 <_Objects_Get_next+0x1c> <== NOT EXECUTED *next_id_p = next_id; 118a21: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 118a24: 89 1a mov %ebx,(%edx) <== NOT EXECUTED return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 118a26: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 118a29: 5b pop %ebx <== NOT EXECUTED 118a2a: 5e pop %esi <== NOT EXECUTED 118a2b: 5f pop %edi <== NOT EXECUTED 118a2c: c9 leave <== NOT EXECUTED 118a2d: c3 ret <== NOT EXECUTED 118a2e: 66 90 xchg %ax,%ax <== NOT EXECUTED { Objects_Control *object; Objects_Id next_id; if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX) next_id = information->minimum_id; 118a30: 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) 118a33: 66 39 5f 10 cmp %bx,0x10(%edi) <== NOT EXECUTED 118a37: 73 d5 jae 118a0e <_Objects_Get_next+0x22> <== NOT EXECUTED 118a39: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { *location_p = OBJECTS_ERROR; 118a3c: 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; 118a42: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 118a45: c7 00 ff ff ff ff movl $0xffffffff,(%eax) <== NOT EXECUTED 118a4b: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 118a4d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 118a50: 5b pop %ebx <== NOT EXECUTED 118a51: 5e pop %esi <== NOT EXECUTED 118a52: 5f pop %edi <== NOT EXECUTED 118a53: c9 leave <== NOT EXECUTED 118a54: c3 ret <== NOT EXECUTED 00116b5c <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 116b5c: 55 push %ebp <== NOT EXECUTED 116b5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116b5f: 8b 4d 08 mov 0x8(%ebp),%ecx <== 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; 116b62: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 116b67: 2b 51 08 sub 0x8(%ecx),%edx <== NOT EXECUTED 116b6a: 03 55 0c add 0xc(%ebp),%edx <== NOT EXECUTED if ( information->maximum >= index ) { 116b6d: 0f b7 41 10 movzwl 0x10(%ecx),%eax <== NOT EXECUTED 116b71: 39 c2 cmp %eax,%edx <== NOT EXECUTED 116b73: 77 17 ja 116b8c <_Objects_Get_no_protection+0x30> <== NOT EXECUTED if ( (the_object = information->local_table[ index ]) != NULL ) { 116b75: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 116b78: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED 116b7b: 85 c0 test %eax,%eax <== NOT EXECUTED 116b7d: 74 0d je 116b8c <_Objects_Get_no_protection+0x30> <== NOT EXECUTED *location = OBJECTS_LOCAL; 116b7f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 116b82: c7 02 00 00 00 00 movl $0x0,(%edx) <== 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; return NULL; } 116b88: c9 leave <== NOT EXECUTED 116b89: c3 ret <== NOT EXECUTED 116b8a: 66 90 xchg %ax,%ax <== 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; 116b8c: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 116b8f: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 116b95: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; } 116b97: c9 leave <== NOT EXECUTED 116b98: c3 ret <== NOT EXECUTED 0010bc40 <_Objects_Handler_initialization>: uint32_t maximum_nodes, uint32_t maximum_global_objects ) #else void _Objects_Handler_initialization(void) #endif { 10bc40: 55 push %ebp <== NOT EXECUTED 10bc41: 89 e5 mov %esp,%ebp <== NOT EXECUTED node, maximum_nodes, maximum_global_objects ); #endif } 10bc43: c9 leave <== NOT EXECUTED 10bc44: c3 ret <== NOT EXECUTED 0010caf8 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10caf8: 55 push %ebp <== NOT EXECUTED 10caf9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cafb: 53 push %ebx <== NOT EXECUTED 10cafc: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10caff: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cb02: 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 ) 10cb05: 85 db test %ebx,%ebx <== NOT EXECUTED 10cb07: 74 7b je 10cb84 <_Objects_Id_to_name+0x8c> <== NOT EXECUTED return OBJECTS_INVALID_NAME; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10cb09: 85 c0 test %eax,%eax <== NOT EXECUTED 10cb0b: 74 53 je 10cb60 <_Objects_Id_to_name+0x68> <== NOT EXECUTED 10cb0d: 89 c1 mov %eax,%ecx <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10cb0f: 89 ca mov %ecx,%edx <== NOT EXECUTED 10cb11: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10cb14: 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. 10cb17: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10cb1a: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10cb1d: 77 59 ja 10cb78 <_Objects_Id_to_name+0x80> <== 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 ] ) 10cb1f: 8b 14 95 8c 16 12 00 mov 0x12168c(,%edx,4),%edx <== NOT EXECUTED 10cb26: 85 d2 test %edx,%edx <== NOT EXECUTED 10cb28: 74 4e je 10cb78 <_Objects_Id_to_name+0x80> <== NOT EXECUTED return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 10cb2a: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10cb2c: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED 10cb2f: 8b 14 82 mov (%edx,%eax,4),%edx <== NOT EXECUTED if ( !information ) 10cb32: 85 d2 test %edx,%edx <== NOT EXECUTED 10cb34: 74 42 je 10cb78 <_Objects_Id_to_name+0x80> <== NOT EXECUTED return OBJECTS_INVALID_ID; if ( information->is_string ) 10cb36: 80 7a 38 00 cmpb $0x0,0x38(%edx) <== NOT EXECUTED 10cb3a: 75 3c jne 10cb78 <_Objects_Id_to_name+0x80> <== NOT EXECUTED return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &ignored_location ); 10cb3c: 50 push %eax <== NOT EXECUTED 10cb3d: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10cb40: 50 push %eax <== NOT EXECUTED 10cb41: 51 push %ecx <== NOT EXECUTED 10cb42: 52 push %edx <== NOT EXECUTED 10cb43: e8 4c ff ff ff call 10ca94 <_Objects_Get> <== NOT EXECUTED if ( !the_object ) 10cb48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cb4b: 85 c0 test %eax,%eax <== NOT EXECUTED 10cb4d: 74 29 je 10cb78 <_Objects_Id_to_name+0x80> <== NOT EXECUTED return OBJECTS_INVALID_ID; *name = the_object->name; 10cb4f: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10cb52: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10cb54: e8 13 08 00 00 call 10d36c <_Thread_Enable_dispatch> <== NOT EXECUTED 10cb59: 31 c0 xor %eax,%eax <== NOT EXECUTED return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 10cb5b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cb5e: c9 leave <== NOT EXECUTED 10cb5f: c3 ret <== NOT EXECUTED Objects_Locations ignored_location; if ( !name ) return OBJECTS_INVALID_NAME; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10cb60: a1 7c 17 12 00 mov 0x12177c,%eax <== NOT EXECUTED 10cb65: 8b 48 08 mov 0x8(%eax),%ecx <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10cb68: 89 ca mov %ecx,%edx <== NOT EXECUTED 10cb6a: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10cb6d: 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. 10cb70: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10cb73: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10cb76: 76 a7 jbe 10cb1f <_Objects_Id_to_name+0x27> <== NOT EXECUTED if ( !the_object ) return OBJECTS_INVALID_ID; *name = the_object->name; _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10cb78: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } 10cb7d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cb80: c9 leave <== NOT EXECUTED 10cb81: c3 ret <== NOT EXECUTED 10cb82: 66 90 xchg %ax,%ax <== NOT EXECUTED Objects_Id tmpId; Objects_Information *information; Objects_Control *the_object = (Objects_Control *) 0; Objects_Locations ignored_location; if ( !name ) 10cb84: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10cb89: eb f2 jmp 10cb7d <_Objects_Id_to_name+0x85> <== NOT EXECUTED 0010bac8 <_Objects_Initialize_information>: , bool supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 10bac8: 55 push %ebp <== NOT EXECUTED 10bac9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bacb: 57 push %edi <== NOT EXECUTED 10bacc: 56 push %esi <== NOT EXECUTED 10bacd: 53 push %ebx <== NOT EXECUTED 10bace: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10bad1: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10bad4: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10bad7: 8b 75 20 mov 0x20(%ebp),%esi <== NOT EXECUTED 10bada: 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; 10bade: 89 17 mov %edx,(%edi) <== NOT EXECUTED information->the_class = the_class; 10bae0: 66 89 5f 04 mov %bx,0x4(%edi) <== NOT EXECUTED information->is_string = is_string; 10bae4: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 10bae7: 88 47 38 mov %al,0x38(%edi) <== NOT EXECUTED information->local_table = 0; information->inactive_per_block = 0; 10baea: c7 47 30 00 00 00 00 movl $0x0,0x30(%edi) <== NOT EXECUTED information->object_blocks = 0; 10baf1: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi) <== NOT EXECUTED information->inactive = 0; 10baf8: 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; 10bafe: 8b 04 95 cc e9 11 00 mov 0x11e9cc(,%edx,4),%eax <== NOT EXECUTED 10bb05: 89 3c 98 mov %edi,(%eax,%ebx,4) <== NOT EXECUTED /* * Set the size of the object */ information->size = size; 10bb08: 89 4f 18 mov %ecx,0x18(%edi) <== NOT EXECUTED /* * Are we operating in unlimited, or auto-extend mode */ information->auto_extend = 10bb0b: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10bb0e: c1 e8 1f shr $0x1f,%eax <== NOT EXECUTED 10bb11: 88 47 12 mov %al,0x12(%edi) <== NOT EXECUTED (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE; maximum &= ~OBJECTS_UNLIMITED_OBJECTS; 10bb14: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10bb17: 81 e1 ff ff ff 7f and $0x7fffffff,%ecx <== NOT EXECUTED /* * The allocation unit is the maximum value */ information->allocation_size = maximum; 10bb1d: 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; 10bb20: c7 47 1c 64 e7 11 00 movl $0x11e764,0x1c(%edi) <== NOT EXECUTED */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 10bb27: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10bb2a: 81 ca 00 00 01 00 or $0x10000,%edx <== NOT EXECUTED 10bb30: c1 e3 1b shl $0x1b,%ebx <== NOT EXECUTED 10bb33: 09 da or %ebx,%edx <== NOT EXECUTED 10bb35: 31 c0 xor %eax,%eax <== NOT EXECUTED 10bb37: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bb39: 0f 95 c0 setne %al <== NOT EXECUTED 10bb3c: 09 c2 or %eax,%edx <== NOT EXECUTED 10bb3e: 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) ) 10bb41: f7 c6 03 00 00 00 test $0x3,%esi <== NOT EXECUTED 10bb47: 75 23 jne 10bb6c <_Objects_Initialize_information+0xa4> <== NOT EXECUTED 10bb49: 89 f0 mov %esi,%eax <== NOT EXECUTED name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & ~(OBJECTS_NAME_ALIGNMENT-1); information->name_length = name_length; 10bb4b: 66 89 47 3a mov %ax,0x3a(%edi) <== NOT EXECUTED 10bb4f: 8d 47 24 lea 0x24(%edi),%eax <== NOT EXECUTED 10bb52: 89 47 20 mov %eax,0x20(%edi) <== NOT EXECUTED 10bb55: c7 47 24 00 00 00 00 movl $0x0,0x24(%edi) <== NOT EXECUTED 10bb5c: 8d 47 20 lea 0x20(%edi),%eax <== NOT EXECUTED 10bb5f: 89 47 28 mov %eax,0x28(%edi) <== NOT EXECUTED /* * Initialize objects .. if there are any */ if ( maximum ) { 10bb62: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bb64: 75 0e jne 10bb74 <_Objects_Initialize_information+0xac> <== NOT EXECUTED _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10bb66: 5b pop %ebx <== NOT EXECUTED 10bb67: 5e pop %esi <== NOT EXECUTED 10bb68: 5f pop %edi <== NOT EXECUTED 10bb69: c9 leave <== NOT EXECUTED 10bb6a: c3 ret <== NOT EXECUTED 10bb6b: 90 nop <== NOT EXECUTED */ name_length = maximum_name_length; if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) ) name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & 10bb6c: 8d 46 04 lea 0x4(%esi),%eax <== NOT EXECUTED 10bb6f: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED 10bb72: eb d7 jmp 10bb4b <_Objects_Initialize_information+0x83> <== NOT EXECUTED /* * Reset the maximum value. It will be updated when the information is * extended. */ information->maximum = 0; 10bb74: 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 ); 10bb7a: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10bb7d: 5b pop %ebx <== NOT EXECUTED 10bb7e: 5e pop %esi <== NOT EXECUTED 10bb7f: 5f pop %edi <== NOT EXECUTED 10bb80: 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 ); 10bb81: e9 8e fa ff ff jmp 10b614 <_Objects_Extend_information> <== NOT EXECUTED 0010bbbc <_Objects_Name_to_id_u32>: Objects_Information *information, uint32_t name, uint32_t node, Objects_Id *id ) { 10bbbc: 55 push %ebp <== NOT EXECUTED 10bbbd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bbbf: 57 push %edi <== NOT EXECUTED 10bbc0: 56 push %esi <== NOT EXECUTED 10bbc1: 53 push %ebx <== NOT EXECUTED 10bbc2: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10bbc5: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == FALSE */ if ( !id ) 10bbc8: 85 ff test %edi,%edi <== NOT EXECUTED 10bbca: 74 5c je 10bc28 <_Objects_Name_to_id_u32+0x6c> <== NOT EXECUTED return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 10bbcc: 85 f6 test %esi,%esi <== NOT EXECUTED 10bbce: 74 38 je 10bc08 <_Objects_Name_to_id_u32+0x4c> <== NOT EXECUTED return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10bbd0: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bbd3: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10bbd6: 66 85 c0 test %ax,%ax <== NOT EXECUTED 10bbd9: 74 2d je 10bc08 <_Objects_Name_to_id_u32+0x4c> <== NOT EXECUTED 10bbdb: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10bbde: 85 d2 test %edx,%edx <== NOT EXECUTED 10bbe0: 75 32 jne 10bc14 <_Objects_Name_to_id_u32+0x58> <== NOT EXECUTED search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 10bbe2: 0f b7 d8 movzwl %ax,%ebx <== NOT EXECUTED 10bbe5: 85 db test %ebx,%ebx <== NOT EXECUTED 10bbe7: 74 1f je 10bc08 <_Objects_Name_to_id_u32+0x4c> <== NOT EXECUTED if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10bbe9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bbec: 8b 48 1c mov 0x1c(%eax),%ecx <== NOT EXECUTED 10bbef: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED if ( search_local_node ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { the_object = information->local_table[ index ]; 10bbf4: 8b 04 91 mov (%ecx,%edx,4),%eax <== NOT EXECUTED if ( !the_object ) 10bbf7: 85 c0 test %eax,%eax <== NOT EXECUTED 10bbf9: 74 05 je 10bc00 <_Objects_Name_to_id_u32+0x44> <== NOT EXECUTED continue; if ( name == the_object->name.name_u32 ) { 10bbfb: 39 70 0c cmp %esi,0xc(%eax) <== NOT EXECUTED 10bbfe: 74 34 je 10bc34 <_Objects_Name_to_id_u32+0x78> <== NOT EXECUTED search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 10bc00: 42 inc %edx <== NOT EXECUTED 10bc01: 39 da cmp %ebx,%edx <== NOT EXECUTED 10bc03: 76 ef jbe 10bbf4 <_Objects_Name_to_id_u32+0x38> <== NOT EXECUTED 10bc05: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10bc08: 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 } 10bc0d: 5b pop %ebx <== NOT EXECUTED 10bc0e: 5e pop %esi <== NOT EXECUTED 10bc0f: 5f pop %edi <== NOT EXECUTED 10bc10: c9 leave <== NOT EXECUTED 10bc11: c3 ret <== NOT EXECUTED 10bc12: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10bc14: 81 7d 10 ff ff ff 7f cmpl $0x7fffffff,0x10(%ebp) <== NOT EXECUTED 10bc1b: 74 c5 je 10bbe2 <_Objects_Name_to_id_u32+0x26> <== NOT EXECUTED 10bc1d: 83 7d 10 01 cmpl $0x1,0x10(%ebp) <== NOT EXECUTED 10bc21: 75 e5 jne 10bc08 <_Objects_Name_to_id_u32+0x4c> <== NOT EXECUTED 10bc23: eb bd jmp 10bbe2 <_Objects_Name_to_id_u32+0x26> <== NOT EXECUTED 10bc25: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == FALSE */ if ( !id ) 10bc28: b8 02 00 00 00 mov $0x2,%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 } 10bc2d: 5b pop %ebx <== NOT EXECUTED 10bc2e: 5e pop %esi <== NOT EXECUTED 10bc2f: 5f pop %edi <== NOT EXECUTED 10bc30: c9 leave <== NOT EXECUTED 10bc31: c3 ret <== NOT EXECUTED 10bc32: 66 90 xchg %ax,%ax <== NOT EXECUTED the_object = information->local_table[ index ]; if ( !the_object ) continue; if ( name == the_object->name.name_u32 ) { *id = the_object->id; 10bc34: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10bc37: 89 07 mov %eax,(%edi) <== NOT EXECUTED 10bc39: 31 c0 xor %eax,%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 } 10bc3b: 5b pop %ebx <== NOT EXECUTED 10bc3c: 5e pop %esi <== NOT EXECUTED 10bc3d: 5f pop %edi <== NOT EXECUTED 10bc3e: c9 leave <== NOT EXECUTED 10bc3f: c3 ret <== NOT EXECUTED 0010bb88 <_Objects_Namespace_remove>: void _Objects_Namespace_remove( Objects_Information *information, Objects_Control *the_object ) { 10bb88: 55 push %ebp <== NOT EXECUTED 10bb89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb8b: 53 push %ebx <== NOT EXECUTED 10bb8c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bb8f: 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 ) 10bb92: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bb95: 80 78 38 00 cmpb $0x0,0x38(%eax) <== NOT EXECUTED 10bb99: 74 13 je 10bbae <_Objects_Namespace_remove+0x26> <== NOT EXECUTED 10bb9b: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10bb9e: 85 c0 test %eax,%eax <== NOT EXECUTED 10bba0: 74 0c je 10bbae <_Objects_Namespace_remove+0x26> <== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10bba2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bba5: 50 push %eax <== NOT EXECUTED 10bba6: e8 19 18 00 00 call 10d3c4 <_Workspace_Free> <== NOT EXECUTED 10bbab: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Clear out either format. */ the_object->name.name_p = NULL; the_object->name.name_u32 = 0; 10bbae: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED } 10bbb5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bbb8: c9 leave <== NOT EXECUTED 10bbb9: c3 ret <== NOT EXECUTED 0010d5e0 <_Objects_Set_name>: bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 10d5e0: 55 push %ebp <== NOT EXECUTED 10d5e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d5e3: 57 push %edi <== NOT EXECUTED 10d5e4: 56 push %esi <== NOT EXECUTED 10d5e5: 53 push %ebx <== NOT EXECUTED 10d5e6: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10d5e9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10d5ec: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED size_t length; const char *s; s = name; length = strnlen( name, information->name_length ) + 1; 10d5ef: 0f b7 43 3a movzwl 0x3a(%ebx),%eax <== NOT EXECUTED 10d5f3: 50 push %eax <== NOT EXECUTED 10d5f4: 57 push %edi <== NOT EXECUTED 10d5f5: e8 5a 5c 00 00 call 113254 <== NOT EXECUTED 10d5fa: 8d 70 01 lea 0x1(%eax),%esi <== NOT EXECUTED if ( information->is_string ) { 10d5fd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d600: 80 7b 38 00 cmpb $0x0,0x38(%ebx) <== NOT EXECUTED 10d604: 75 5a jne 10d660 <_Objects_Set_name+0x80> <== NOT EXECUTED strncpy( d, name, length ); d[ length ] = '\0'; the_object->name.name_p = d; } else { the_object->name.name_u32 = _Objects_Build_name( 10d606: 85 f6 test %esi,%esi <== NOT EXECUTED 10d608: 74 3e je 10d648 <_Objects_Set_name+0x68> <== NOT EXECUTED 10d60a: 0f be 17 movsbl (%edi),%edx <== NOT EXECUTED 10d60d: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10d610: 83 fe 01 cmp $0x1,%esi <== NOT EXECUTED 10d613: 0f 84 ae 00 00 00 je 10d6c7 <_Objects_Set_name+0xe7> <== NOT EXECUTED 10d619: 0f be 47 01 movsbl 0x1(%edi),%eax <== NOT EXECUTED 10d61d: c1 e0 10 shl $0x10,%eax <== NOT EXECUTED 10d620: 09 d0 or %edx,%eax <== NOT EXECUTED 10d622: 83 fe 02 cmp $0x2,%esi <== NOT EXECUTED 10d625: 0f 84 89 00 00 00 je 10d6b4 <_Objects_Set_name+0xd4> <== NOT EXECUTED 10d62b: 0f be 57 02 movsbl 0x2(%edi),%edx <== NOT EXECUTED 10d62f: c1 e2 08 shl $0x8,%edx <== NOT EXECUTED 10d632: 09 c2 or %eax,%edx <== NOT EXECUTED 10d634: 83 fe 03 cmp $0x3,%esi <== NOT EXECUTED 10d637: 0f 84 83 00 00 00 je 10d6c0 <_Objects_Set_name+0xe0> <== NOT EXECUTED 10d63d: 0f be 47 03 movsbl 0x3(%edi),%eax <== NOT EXECUTED 10d641: 09 d0 or %edx,%eax <== NOT EXECUTED 10d643: eb 08 jmp 10d64d <_Objects_Set_name+0x6d> <== NOT EXECUTED 10d645: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10d648: b8 20 20 20 20 mov $0x20202020,%eax <== NOT EXECUTED 10d64d: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10d650: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED 10d653: b0 01 mov $0x1,%al <== NOT EXECUTED ); } return TRUE; } 10d655: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d658: 5b pop %ebx <== NOT EXECUTED 10d659: 5e pop %esi <== NOT EXECUTED 10d65a: 5f pop %edi <== NOT EXECUTED 10d65b: c9 leave <== NOT EXECUTED 10d65c: c3 ret <== NOT EXECUTED 10d65d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED length = strnlen( name, information->name_length ) + 1; if ( information->is_string ) { char *d; d = _Workspace_Allocate( length ); 10d660: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d663: 56 push %esi <== NOT EXECUTED 10d664: e8 ff 17 00 00 call 10ee68 <_Workspace_Allocate> <== NOT EXECUTED 10d669: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !d ) 10d66b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d66e: 85 c0 test %eax,%eax <== NOT EXECUTED 10d670: 74 4a je 10d6bc <_Objects_Set_name+0xdc> <== NOT EXECUTED return FALSE; if ( the_object->name.name_p ) { 10d672: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10d675: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10d678: 85 c0 test %eax,%eax <== NOT EXECUTED 10d67a: 74 16 je 10d692 <_Objects_Set_name+0xb2> <== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10d67c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d67f: 50 push %eax <== NOT EXECUTED 10d680: e8 cb 17 00 00 call 10ee50 <_Workspace_Free> <== NOT EXECUTED the_object->name.name_p = NULL; 10d685: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10d688: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) <== NOT EXECUTED 10d68f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } strncpy( d, name, length ); 10d692: 50 push %eax <== NOT EXECUTED 10d693: 56 push %esi <== NOT EXECUTED 10d694: 57 push %edi <== NOT EXECUTED 10d695: 53 push %ebx <== NOT EXECUTED 10d696: e8 31 5b 00 00 call 1131cc <== NOT EXECUTED d[ length ] = '\0'; 10d69b: c6 04 33 00 movb $0x0,(%ebx,%esi,1) <== NOT EXECUTED the_object->name.name_p = d; 10d69f: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10d6a2: 89 5a 0c mov %ebx,0xc(%edx) <== NOT EXECUTED 10d6a5: b0 01 mov $0x1,%al <== NOT EXECUTED 10d6a7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ); } return TRUE; } 10d6aa: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d6ad: 5b pop %ebx <== NOT EXECUTED 10d6ae: 5e pop %esi <== NOT EXECUTED 10d6af: 5f pop %edi <== NOT EXECUTED 10d6b0: c9 leave <== NOT EXECUTED 10d6b1: c3 ret <== NOT EXECUTED 10d6b2: 66 90 xchg %ax,%ax <== NOT EXECUTED strncpy( d, name, length ); d[ length ] = '\0'; the_object->name.name_p = d; } else { the_object->name.name_u32 = _Objects_Build_name( 10d6b4: 0d 20 20 00 00 or $0x2020,%eax <== NOT EXECUTED 10d6b9: eb 92 jmp 10d64d <_Objects_Set_name+0x6d> <== NOT EXECUTED 10d6bb: 90 nop <== NOT EXECUTED if ( information->is_string ) { char *d; d = _Workspace_Allocate( length ); if ( !d ) 10d6bc: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d6be: eb 95 jmp 10d655 <_Objects_Set_name+0x75> <== NOT EXECUTED strncpy( d, name, length ); d[ length ] = '\0'; the_object->name.name_p = d; } else { the_object->name.name_u32 = _Objects_Build_name( 10d6c0: 89 d0 mov %edx,%eax <== NOT EXECUTED 10d6c2: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 10d6c5: eb 86 jmp 10d64d <_Objects_Set_name+0x6d> <== NOT EXECUTED 10d6c7: 89 d0 mov %edx,%eax <== NOT EXECUTED 10d6c9: 0d 20 20 20 00 or $0x202020,%eax <== NOT EXECUTED 10d6ce: e9 7a ff ff ff jmp 10d64d <_Objects_Set_name+0x6d> <== NOT EXECUTED 0010bc48 <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 10bc48: 55 push %ebp <== NOT EXECUTED 10bc49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc4b: 57 push %edi <== NOT EXECUTED 10bc4c: 56 push %esi <== NOT EXECUTED 10bc4d: 53 push %ebx <== NOT EXECUTED 10bc4e: 83 ec 0c sub $0xc,%esp <== 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 10bc51: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bc54: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10bc57: 0f b7 f0 movzwl %ax,%esi <== 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; 10bc5a: 8b 4a 14 mov 0x14(%edx),%ecx <== NOT EXECUTED 10bc5d: 0f b7 42 10 movzwl 0x10(%edx),%eax <== NOT EXECUTED 10bc61: 29 f0 sub %esi,%eax <== NOT EXECUTED 10bc63: 31 d2 xor %edx,%edx <== NOT EXECUTED 10bc65: f7 f1 div %ecx <== NOT EXECUTED for ( block = 0; block < block_count; block++ ) { 10bc67: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc69: 74 24 je 10bc8f <_Objects_Shrink_information+0x47> <== NOT EXECUTED if ( information->inactive_per_block[ block ] == information->allocation_size ) { 10bc6b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bc6e: 8b 5a 30 mov 0x30(%edx),%ebx <== NOT EXECUTED 10bc71: 3b 0b cmp (%ebx),%ecx <== NOT EXECUTED 10bc73: 74 22 je 10bc97 <_Objects_Shrink_information+0x4f> <== NOT EXECUTED information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; return; 10bc75: 31 d2 xor %edx,%edx <== NOT EXECUTED 10bc77: eb 11 jmp 10bc8a <_Objects_Shrink_information+0x42> <== NOT EXECUTED 10bc79: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } index_base += information->allocation_size; 10bc7c: 01 ce add %ecx,%esi <== NOT EXECUTED 10bc7e: 8d 3c 95 00 00 00 00 lea 0x0(,%edx,4),%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++ ) { if ( information->inactive_per_block[ block ] == information->allocation_size ) { 10bc85: 3b 0c 93 cmp (%ebx,%edx,4),%ecx <== NOT EXECUTED 10bc88: 74 12 je 10bc9c <_Objects_Shrink_information+0x54> <== 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++ ) { 10bc8a: 42 inc %edx <== NOT EXECUTED 10bc8b: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10bc8d: 77 ed ja 10bc7c <_Objects_Shrink_information+0x34> <== NOT EXECUTED return; } index_base += information->allocation_size; } } 10bc8f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bc92: 5b pop %ebx <== NOT EXECUTED 10bc93: 5e pop %esi <== NOT EXECUTED 10bc94: 5f pop %edi <== NOT EXECUTED 10bc95: c9 leave <== NOT EXECUTED 10bc96: c3 ret <== 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++ ) { if ( information->inactive_per_block[ block ] == information->allocation_size ) { 10bc97: 31 ff xor %edi,%edi <== NOT EXECUTED 10bc99: 8d 76 00 lea 0x0(%esi),%esi <== 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; 10bc9c: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bc9f: 8b 4b 20 mov 0x20(%ebx),%ecx <== NOT EXECUTED 10bca2: eb 26 jmp 10bcca <_Objects_Shrink_information+0x82> <== NOT EXECUTED */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 10bca4: 89 f0 mov %esi,%eax <== NOT EXECUTED 10bca6: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bca9: 03 43 14 add 0x14(%ebx),%eax <== NOT EXECUTED 10bcac: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10bcae: 76 24 jbe 10bcd4 <_Objects_Shrink_information+0x8c> <== 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, 10bcb0: 8b 19 mov (%ecx),%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 ); 10bcb2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bcb5: 51 push %ecx <== NOT EXECUTED 10bcb6: e8 21 33 00 00 call 10efdc <_Chain_Extract> <== NOT EXECUTED 10bcbb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { the_object = (Objects_Control *) the_object->Node.next; } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 10bcbe: 85 db test %ebx,%ebx <== NOT EXECUTED 10bcc0: 74 1a je 10bcdc <_Objects_Shrink_information+0x94> <== NOT EXECUTED 10bcc2: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10bcc4: 85 c0 test %eax,%eax <== NOT EXECUTED 10bcc6: 74 14 je 10bcdc <_Objects_Shrink_information+0x94> <== NOT EXECUTED 10bcc8: 89 d9 mov %ebx,%ecx <== 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 10bcca: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10bccd: 0f b7 d0 movzwl %ax,%edx <== NOT EXECUTED */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 10bcd0: 39 f2 cmp %esi,%edx <== NOT EXECUTED 10bcd2: 73 d0 jae 10bca4 <_Objects_Shrink_information+0x5c> <== NOT EXECUTED the_object = NULL; _Chain_Extract( &extract_me->Node ); } else { the_object = (Objects_Control *) the_object->Node.next; 10bcd4: 8b 19 mov (%ecx),%ebx <== NOT EXECUTED } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 10bcd6: 85 db test %ebx,%ebx <== NOT EXECUTED 10bcd8: 75 e8 jne 10bcc2 <_Objects_Shrink_information+0x7a> <== NOT EXECUTED 10bcda: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); 10bcdc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bcdf: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bce2: 8b 42 34 mov 0x34(%edx),%eax <== NOT EXECUTED 10bce5: ff 34 38 pushl (%eax,%edi,1) <== NOT EXECUTED 10bce8: e8 d7 16 00 00 call 10d3c4 <_Workspace_Free> <== NOT EXECUTED information->object_blocks[ block ] = NULL; 10bced: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bcf0: 8b 43 34 mov 0x34(%ebx),%eax <== NOT EXECUTED 10bcf3: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1) <== NOT EXECUTED information->inactive_per_block[ block ] = 0; 10bcfa: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10bcfd: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1) <== NOT EXECUTED information->inactive -= information->allocation_size; 10bd04: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10bd07: 66 29 43 2c sub %ax,0x2c(%ebx) <== NOT EXECUTED 10bd0b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return; } index_base += information->allocation_size; } } 10bd0e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bd11: 5b pop %ebx <== NOT EXECUTED 10bd12: 5e pop %esi <== NOT EXECUTED 10bd13: 5f pop %edi <== NOT EXECUTED 10bd14: c9 leave <== NOT EXECUTED 10bd15: c3 ret <== NOT EXECUTED 0010ec3c <_Partition_Manager_initialization>: */ void _Partition_Manager_initialization( uint32_t maximum_partitions ) { 10ec3c: 55 push %ebp <== NOT EXECUTED 10ec3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ec3f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ec42: 6a 04 push $0x4 <== NOT EXECUTED 10ec44: 6a 00 push $0x0 <== NOT EXECUTED 10ec46: 6a 30 push $0x30 <== NOT EXECUTED 10ec48: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ec4b: 6a 05 push $0x5 <== NOT EXECUTED 10ec4d: 6a 02 push $0x2 <== NOT EXECUTED 10ec4f: 68 40 ee 11 00 push $0x11ee40 <== NOT EXECUTED 10ec54: e8 6f ce ff ff call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10ec59: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_PARTITION, _Partition_MP_Process_packet ); #endif } 10ec5c: c9 leave <== NOT EXECUTED 10ec5d: c3 ret <== NOT EXECUTED 0010bd18 <_Protected_heap_Allocate>: void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ) { 10bd18: 55 push %ebp <== NOT EXECUTED 10bd19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd1b: 53 push %ebx <== NOT EXECUTED 10bd1c: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED void *p; _RTEMS_Lock_allocator(); 10bd1f: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10bd25: e8 9a ef ff ff call 10acc4 <_API_Mutex_Lock> <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 10bd2a: 5a pop %edx <== NOT EXECUTED 10bd2b: 59 pop %ecx <== NOT EXECUTED 10bd2c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10bd2f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bd32: e8 29 35 00 00 call 10f260 <_Heap_Allocate> <== NOT EXECUTED 10bd37: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10bd39: 58 pop %eax <== NOT EXECUTED 10bd3a: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10bd40: e8 c7 ef ff ff call 10ad0c <_API_Mutex_Unlock> <== NOT EXECUTED return p; } 10bd45: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bd47: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bd4a: c9 leave <== NOT EXECUTED 10bd4b: c3 ret <== NOT EXECUTED 0010dbb0 <_Protected_heap_Allocate_aligned>: void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ) { 10dbb0: 55 push %ebp <== NOT EXECUTED 10dbb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dbb3: 53 push %ebx <== NOT EXECUTED 10dbb4: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED void *p; _RTEMS_Lock_allocator(); 10dbb7: ff 35 b4 3c 12 00 pushl 0x123cb4 <== NOT EXECUTED 10dbbd: e8 be e9 ff ff call 10c580 <_API_Mutex_Lock> <== NOT EXECUTED p = _Heap_Allocate_aligned( the_heap, size, alignment ); 10dbc2: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10dbc5: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dbc8: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dbcb: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10dbce: e8 49 f0 ff ff call 10cc1c <_Heap_Allocate_aligned> <== NOT EXECUTED 10dbd3: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10dbd5: 58 pop %eax <== NOT EXECUTED 10dbd6: ff 35 b4 3c 12 00 pushl 0x123cb4 <== NOT EXECUTED 10dbdc: e8 e7 e9 ff ff call 10c5c8 <_API_Mutex_Unlock> <== NOT EXECUTED return p; } 10dbe1: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10dbe3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10dbe6: c9 leave <== NOT EXECUTED 10dbe7: c3 ret <== NOT EXECUTED 0010dc1c <_Protected_heap_Extend>: bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ) { 10dc1c: 55 push %ebp <== NOT EXECUTED 10dc1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc1f: 53 push %ebx <== NOT EXECUTED 10dc20: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 10dc23: ff 35 b4 3c 12 00 pushl 0x123cb4 <== NOT EXECUTED 10dc29: e8 52 e9 ff ff call 10c580 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 10dc2e: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10dc31: 50 push %eax <== NOT EXECUTED 10dc32: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dc35: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dc38: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10dc3b: e8 b8 37 00 00 call 1113f8 <_Heap_Extend> <== NOT EXECUTED 10dc40: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10dc42: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10dc45: ff 35 b4 3c 12 00 pushl 0x123cb4 <== NOT EXECUTED 10dc4b: e8 78 e9 ff ff call 10c5c8 <_API_Mutex_Unlock> <== NOT EXECUTED 10dc50: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dc53: 85 db test %ebx,%ebx <== NOT EXECUTED 10dc55: 0f 94 c0 sete %al <== NOT EXECUTED return (status == HEAP_EXTEND_SUCCESSFUL); } 10dc58: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10dc5b: c9 leave <== NOT EXECUTED 10dc5c: c3 ret <== NOT EXECUTED 0010bd4c <_Protected_heap_Free>: bool _Protected_heap_Free( Heap_Control *the_heap, void *start_address ) { 10bd4c: 55 push %ebp <== NOT EXECUTED 10bd4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd4f: 53 push %ebx <== NOT EXECUTED 10bd50: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED bool status; _RTEMS_Lock_allocator(); 10bd53: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10bd59: e8 66 ef ff ff call 10acc4 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 10bd5e: 5a pop %edx <== NOT EXECUTED 10bd5f: 59 pop %ecx <== NOT EXECUTED 10bd60: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10bd63: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bd66: e8 89 35 00 00 call 10f2f4 <_Heap_Free> <== NOT EXECUTED 10bd6b: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10bd6d: 58 pop %eax <== NOT EXECUTED 10bd6e: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10bd74: e8 93 ef ff ff call 10ad0c <_API_Mutex_Unlock> <== NOT EXECUTED return status; } 10bd79: 88 d8 mov %bl,%al <== NOT EXECUTED 10bd7b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bd7e: c9 leave <== NOT EXECUTED 10bd7f: c3 ret <== NOT EXECUTED 001169d8 <_Protected_heap_Get_block_size>: bool _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ) { 1169d8: 55 push %ebp <== NOT EXECUTED 1169d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1169db: 53 push %ebx <== NOT EXECUTED 1169dc: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED bool status; _RTEMS_Lock_allocator(); 1169df: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 1169e5: e8 da 42 ff ff call 10acc4 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 1169ea: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1169ed: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1169f0: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1169f3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1169f6: e8 49 02 00 00 call 116c44 <_Heap_Size_of_user_area> <== NOT EXECUTED 1169fb: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 1169fd: 58 pop %eax <== NOT EXECUTED 1169fe: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 116a04: e8 03 43 ff ff call 10ad0c <_API_Mutex_Unlock> <== NOT EXECUTED return status; } 116a09: 88 d8 mov %bl,%al <== NOT EXECUTED 116a0b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 116a0e: c9 leave <== NOT EXECUTED 116a0f: c3 ret <== NOT EXECUTED 00111134 <_Protected_heap_Get_free_information>: bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 111134: 55 push %ebp <== NOT EXECUTED 111135: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111137: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED /* * TBD: _Heap_Get_free_information does not error check or return status. */ _RTEMS_Lock_allocator(); 11113a: ff 35 d4 12 16 00 pushl 0x1612d4 <== NOT EXECUTED 111140: e8 1f eb ff ff call 10fc64 <_API_Mutex_Lock> <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 111145: 5a pop %edx <== NOT EXECUTED 111146: 59 pop %ecx <== NOT EXECUTED 111147: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11114a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11114d: e8 ee 57 01 00 call 126940 <_Heap_Get_free_information> <== NOT EXECUTED _RTEMS_Unlock_allocator(); 111152: 58 pop %eax <== NOT EXECUTED 111153: ff 35 d4 12 16 00 pushl 0x1612d4 <== NOT EXECUTED 111159: e8 4e eb ff ff call 10fcac <_API_Mutex_Unlock> <== NOT EXECUTED return true; } 11115e: b0 01 mov $0x1,%al <== NOT EXECUTED 111160: c9 leave <== NOT EXECUTED 111161: c3 ret <== NOT EXECUTED 00126c28 <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 126c28: 55 push %ebp <== NOT EXECUTED 126c29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126c2b: 56 push %esi <== NOT EXECUTED 126c2c: 53 push %ebx <== NOT EXECUTED 126c2d: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 126c30: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Heap_Get_information_status status; if ( !the_heap ) 126c33: 85 f6 test %esi,%esi <== NOT EXECUTED 126c35: 74 39 je 126c70 <_Protected_heap_Get_information+0x48> <== NOT EXECUTED return false; if ( !the_info ) 126c37: 85 db test %ebx,%ebx <== NOT EXECUTED 126c39: 74 35 je 126c70 <_Protected_heap_Get_information+0x48> <== NOT EXECUTED return false; _RTEMS_Lock_allocator(); 126c3b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 126c3e: ff 35 d4 12 16 00 pushl 0x1612d4 <== NOT EXECUTED 126c44: e8 1b 90 fe ff call 10fc64 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Get_information( the_heap, the_info ); 126c49: 5a pop %edx <== NOT EXECUTED 126c4a: 59 pop %ecx <== NOT EXECUTED 126c4b: 53 push %ebx <== NOT EXECUTED 126c4c: 56 push %esi <== NOT EXECUTED 126c4d: e8 e2 8a 00 00 call 12f734 <_Heap_Get_information> <== NOT EXECUTED 126c52: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 126c54: 58 pop %eax <== NOT EXECUTED 126c55: ff 35 d4 12 16 00 pushl 0x1612d4 <== NOT EXECUTED 126c5b: e8 4c 90 fe ff call 10fcac <_API_Mutex_Unlock> <== NOT EXECUTED if ( status == HEAP_GET_INFORMATION_SUCCESSFUL ) 126c60: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126c63: 85 db test %ebx,%ebx <== NOT EXECUTED 126c65: 0f 94 c0 sete %al <== NOT EXECUTED return true; return false; } 126c68: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126c6b: 5b pop %ebx <== NOT EXECUTED 126c6c: 5e pop %esi <== NOT EXECUTED 126c6d: c9 leave <== NOT EXECUTED 126c6e: c3 ret <== NOT EXECUTED 126c6f: 90 nop <== NOT EXECUTED _RTEMS_Lock_allocator(); status = _Heap_Get_information( the_heap, the_info ); _RTEMS_Unlock_allocator(); if ( status == HEAP_GET_INFORMATION_SUCCESSFUL ) 126c70: 31 c0 xor %eax,%eax <== NOT EXECUTED return true; return false; } 126c72: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126c75: 5b pop %ebx <== NOT EXECUTED 126c76: 5e pop %esi <== NOT EXECUTED 126c77: c9 leave <== NOT EXECUTED 126c78: c3 ret <== NOT EXECUTED 00116a10 <_Protected_heap_Resize_block>: bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ) { 116a10: 55 push %ebp <== NOT EXECUTED 116a11: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116a13: 53 push %ebx <== NOT EXECUTED 116a14: 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(); 116a17: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 116a1d: e8 a2 42 ff ff call 10acc4 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Resize_block( 116a22: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 116a25: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 116a28: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 116a2b: 50 push %eax <== NOT EXECUTED 116a2c: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 116a2f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 116a32: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 116a35: e8 1e 00 00 00 call 116a58 <_Heap_Resize_block> <== NOT EXECUTED 116a3a: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_heap, starting_address, size, &old_mem_size, &avail_mem_size ); _RTEMS_Unlock_allocator(); 116a3c: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 116a3f: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 116a45: e8 c2 42 ff ff call 10ad0c <_API_Mutex_Unlock> <== NOT EXECUTED 116a4a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116a4d: 85 db test %ebx,%ebx <== NOT EXECUTED 116a4f: 0f 94 c0 sete %al <== NOT EXECUTED return (status == HEAP_RESIZE_SUCCESSFUL); } 116a52: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 116a55: c9 leave <== NOT EXECUTED 116a56: c3 ret <== NOT EXECUTED 0010dd98 <_Protected_heap_Walk>: bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 10dd98: 55 push %ebp <== NOT EXECUTED 10dd99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dd9b: 57 push %edi <== NOT EXECUTED 10dd9c: 56 push %esi <== NOT EXECUTED 10dd9d: 53 push %ebx <== NOT EXECUTED 10dd9e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10dda1: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10dda4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10dda7: 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 ) { 10ddaa: a1 f8 3b 12 00 mov 0x123bf8,%eax <== NOT EXECUTED 10ddaf: 85 c0 test %eax,%eax <== NOT EXECUTED 10ddb1: 74 19 je 10ddcc <_Protected_heap_Walk+0x34> <== NOT EXECUTED _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 10ddb3: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10ddb6: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 10ddb9: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10ddbc: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED } return status; } 10ddbf: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ddc2: 5b pop %ebx <== NOT EXECUTED 10ddc3: 5e pop %esi <== NOT EXECUTED 10ddc4: 5f pop %edi <== NOT EXECUTED 10ddc5: 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 ); 10ddc6: e9 11 38 00 00 jmp 1115dc <_Heap_Walk> <== NOT EXECUTED 10ddcb: 90 nop <== NOT EXECUTED * a critical section, it should be safe to walk it unlocked. * * NOTE: Dispatching is also disabled during initialization. */ if ( !_Thread_Dispatch_disable_level ) { _RTEMS_Lock_allocator(); 10ddcc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ddcf: ff 35 b4 3c 12 00 pushl 0x123cb4 <== NOT EXECUTED 10ddd5: e8 a6 e7 ff ff call 10c580 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Walk( the_heap, source, do_dump ); 10ddda: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10dddd: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10dde0: 50 push %eax <== NOT EXECUTED 10dde1: 56 push %esi <== NOT EXECUTED 10dde2: 57 push %edi <== NOT EXECUTED 10dde3: e8 f4 37 00 00 call 1115dc <_Heap_Walk> <== NOT EXECUTED 10dde8: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10ddea: 58 pop %eax <== NOT EXECUTED 10ddeb: ff 35 b4 3c 12 00 pushl 0x123cb4 <== NOT EXECUTED 10ddf1: e8 d2 e7 ff ff call 10c5c8 <_API_Mutex_Unlock> <== NOT EXECUTED 10ddf6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { status = _Heap_Walk( the_heap, source, do_dump ); } return status; } 10ddf9: 88 d8 mov %bl,%al <== NOT EXECUTED 10ddfb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ddfe: 5b pop %ebx <== NOT EXECUTED 10ddff: 5e pop %esi <== NOT EXECUTED 10de00: 5f pop %edi <== NOT EXECUTED 10de01: c9 leave <== NOT EXECUTED 10de02: c3 ret <== NOT EXECUTED 0010ab0c <_RTEMS_API_Initialize>: */ void _RTEMS_API_Initialize( rtems_configuration_table *configuration_table ) { 10ab0c: 55 push %ebp <== NOT EXECUTED 10ab0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ab0f: 53 push %ebx <== NOT EXECUTED 10ab10: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED rtems_api_configuration_table *api_configuration; api_configuration = configuration_table->RTEMS_api_configuration; 10ab13: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ab16: 8b 58 40 mov 0x40(%eax),%ebx <== NOT EXECUTED _Objects_Information_table[OBJECTS_CLASSIC_API] = _RTEMS_Objects; 10ab19: c7 05 d4 e9 11 00 80 movl $0x11ec80,0x11e9d4 <== NOT EXECUTED 10ab20: ec 11 00 <== NOT EXECUTED _Attributes_Handler_initialization(); _Interrupt_Manager_initialization(); 10ab23: e8 e4 40 00 00 call 10ec0c <_Interrupt_Manager_initialization> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) _Multiprocessing_Manager_initialization(); #endif _RTEMS_tasks_Manager_initialization( api_configuration->maximum_tasks ); 10ab28: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab2b: ff 33 pushl (%ebx) <== NOT EXECUTED 10ab2d: e8 52 42 00 00 call 10ed84 <_RTEMS_tasks_Manager_initialization> <== NOT EXECUTED _Timer_Manager_initialization( api_configuration->maximum_timers ); 10ab32: 58 pop %eax <== NOT EXECUTED 10ab33: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10ab36: e8 75 41 00 00 call 10ecb0 <_Timer_Manager_initialization> <== NOT EXECUTED _Signal_Manager_initialization(); 10ab3b: e8 cc 41 00 00 call 10ed0c <_Signal_Manager_initialization> <== NOT EXECUTED _Event_Manager_initialization(); 10ab40: e8 b7 40 00 00 call 10ebfc <_Event_Manager_initialization> <== NOT EXECUTED _Message_queue_Manager_initialization( 10ab45: 58 pop %eax <== NOT EXECUTED 10ab46: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10ab49: e8 c6 40 00 00 call 10ec14 <_Message_queue_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_message_queues ); _Semaphore_Manager_initialization( api_configuration->maximum_semaphores ); 10ab4e: 58 pop %eax <== NOT EXECUTED 10ab4f: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 10ab52: e8 91 41 00 00 call 10ece8 <_Semaphore_Manager_initialization> <== NOT EXECUTED _Partition_Manager_initialization( api_configuration->maximum_partitions ); 10ab57: 58 pop %eax <== NOT EXECUTED 10ab58: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 10ab5b: e8 dc 40 00 00 call 10ec3c <_Partition_Manager_initialization> <== NOT EXECUTED _Region_Manager_initialization( api_configuration->maximum_regions ); 10ab60: 59 pop %ecx <== NOT EXECUTED 10ab61: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10ab64: e8 1f 41 00 00 call 10ec88 <_Region_Manager_initialization> <== NOT EXECUTED _Dual_ported_memory_Manager_initialization( api_configuration->maximum_ports); 10ab69: 5a pop %edx <== NOT EXECUTED 10ab6a: ff 73 1c pushl 0x1c(%ebx) <== NOT EXECUTED 10ab6d: e8 66 40 00 00 call 10ebd8 <_Dual_ported_memory_Manager_initialization> <== NOT EXECUTED _Rate_monotonic_Manager_initialization( api_configuration->maximum_periods ); 10ab72: 58 pop %eax <== NOT EXECUTED 10ab73: ff 73 20 pushl 0x20(%ebx) <== NOT EXECUTED 10ab76: e8 e5 40 00 00 call 10ec60 <_Rate_monotonic_Manager_initialization> <== NOT EXECUTED _Barrier_Manager_initialization( api_configuration->maximum_barriers ); 10ab7b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ab7e: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 10ab81: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10ab84: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ab87: 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 ); 10ab88: e9 27 40 00 00 jmp 10ebb4 <_Barrier_Manager_initialization> <== NOT EXECUTED 0010ef18 <_RTEMS_Tasks_Invoke_task_variable_dtor>: void _RTEMS_Tasks_Invoke_task_variable_dtor( Thread_Control *the_thread, rtems_task_variable_t *tvp ) { 10ef18: 55 push %ebp <== NOT EXECUTED 10ef19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ef1b: 56 push %esi <== NOT EXECUTED 10ef1c: 53 push %ebx <== NOT EXECUTED 10ef1d: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED void (*dtor)(void *); void *value; dtor = tvp->dtor; 10ef20: 8b 4b 10 mov 0x10(%ebx),%ecx <== NOT EXECUTED if (_Thread_Is_executing(the_thread)) { 10ef23: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ef26: 3b 05 bc ea 11 00 cmp 0x11eabc,%eax <== NOT EXECUTED 10ef2c: 74 1e je 10ef4c <_RTEMS_Tasks_Invoke_task_variable_dtor+0x34> <== NOT EXECUTED value = *tvp->ptr; *tvp->ptr = tvp->gval; } else { value = tvp->tval; 10ef2e: 8b 73 0c mov 0xc(%ebx),%esi <== NOT EXECUTED } if ( dtor ) 10ef31: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ef33: 74 09 je 10ef3e <_RTEMS_Tasks_Invoke_task_variable_dtor+0x26> <== NOT EXECUTED (*dtor)(value); 10ef35: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ef38: 56 push %esi <== NOT EXECUTED 10ef39: ff d1 call *%ecx <== NOT EXECUTED 10ef3b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Workspace_Free(tvp); 10ef3e: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 10ef41: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ef44: 5b pop %ebx <== NOT EXECUTED 10ef45: 5e pop %esi <== NOT EXECUTED 10ef46: c9 leave <== NOT EXECUTED } if ( dtor ) (*dtor)(value); _Workspace_Free(tvp); 10ef47: e9 78 e4 ff ff jmp 10d3c4 <_Workspace_Free> <== NOT EXECUTED void (*dtor)(void *); void *value; dtor = tvp->dtor; if (_Thread_Is_executing(the_thread)) { value = *tvp->ptr; 10ef4c: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 10ef4f: 8b 32 mov (%edx),%esi <== NOT EXECUTED *tvp->ptr = tvp->gval; 10ef51: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10ef54: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10ef56: eb d9 jmp 10ef31 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x19> <== NOT EXECUTED 0010ee7c <_RTEMS_tasks_Create_extension>: bool _RTEMS_tasks_Create_extension( Thread_Control *executing, Thread_Control *created ) { 10ee7c: 55 push %ebp <== NOT EXECUTED 10ee7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ee7f: 53 push %ebx <== NOT EXECUTED 10ee80: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ee83: 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() ) 10ee86: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10ee8b: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10ee8e: 80 78 04 01 cmpb $0x1,0x4(%eax) <== NOT EXECUTED 10ee92: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10ee94: 83 e0 c0 and $0xffffffc0,%eax <== NOT EXECUTED 10ee97: 83 c0 60 add $0x60,%eax <== NOT EXECUTED to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); 10ee9a: 50 push %eax <== NOT EXECUTED 10ee9b: e8 3c e5 ff ff call 10d3dc <_Workspace_Allocate> <== NOT EXECUTED 10eea0: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !api ) 10eea2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eea5: 85 c0 test %eax,%eax <== NOT EXECUTED 10eea7: 74 67 je 10ef10 <_RTEMS_tasks_Create_extension+0x94> <== NOT EXECUTED return false; created->API_Extensions[ THREAD_API_RTEMS ] = api; 10eea9: 89 83 f4 00 00 00 mov %eax,0xf4(%ebx) <== NOT EXECUTED api->pending_events = EVENT_SETS_NONE_PENDING; 10eeaf: c7 00 00 00 00 00 movl $0x0,(%eax) <== 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 10eeb5: c6 40 08 01 movb $0x1,0x8(%eax) <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of 10eeb9: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) <== NOT EXECUTED * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 10eec0: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) <== NOT EXECUTED * 10eec7: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10eece: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10eed5: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) <== NOT EXECUTED _ASR_Initialize( &api->Signal ); created->task_variables = NULL; 10eedc: c7 83 04 01 00 00 00 movl $0x0,0x104(%ebx) <== NOT EXECUTED 10eee3: 00 00 00 <== NOT EXECUTED if ( rtems_configuration_get_notepads_enabled() ) { 10eee6: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10eeeb: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10eeee: 80 78 04 00 cmpb $0x0,0x4(%eax) <== NOT EXECUTED 10eef2: 74 12 je 10ef06 <_RTEMS_tasks_Create_extension+0x8a> <== NOT EXECUTED 10eef4: 31 c0 xor %eax,%eax <== NOT EXECUTED 10eef6: 66 90 xchg %ax,%ax <== NOT EXECUTED for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; 10eef8: c7 44 82 20 00 00 00 movl $0x0,0x20(%edx,%eax,4) <== NOT EXECUTED 10eeff: 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++) 10ef00: 40 inc %eax <== NOT EXECUTED 10ef01: 83 f8 10 cmp $0x10,%eax <== NOT EXECUTED 10ef04: 75 f2 jne 10eef8 <_RTEMS_tasks_Create_extension+0x7c> <== NOT EXECUTED 10ef06: b0 01 mov $0x1,%al <== NOT EXECUTED api->Notepads[i] = 0; } return true; } 10ef08: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ef0b: c9 leave <== NOT EXECUTED 10ef0c: c3 ret <== NOT EXECUTED 10ef0d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !rtems_configuration_get_notepads_enabled() ) to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); if ( !api ) 10ef10: 31 c0 xor %eax,%eax <== NOT EXECUTED for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; } return true; } 10ef12: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ef15: c9 leave <== NOT EXECUTED 10ef16: c3 ret <== NOT EXECUTED 0010ee28 <_RTEMS_tasks_Delete_extension>: User_extensions_routine _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 10ee28: 55 push %ebp <== NOT EXECUTED 10ee29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ee2b: 56 push %esi <== NOT EXECUTED 10ee2c: 53 push %ebx <== NOT EXECUTED 10ee2d: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Free per task variable memory */ tvp = deleted->task_variables; 10ee30: 8b 86 04 01 00 00 mov 0x104(%esi),%eax <== NOT EXECUTED deleted->task_variables = NULL; 10ee36: c7 86 04 01 00 00 00 movl $0x0,0x104(%esi) <== NOT EXECUTED 10ee3d: 00 00 00 <== NOT EXECUTED while (tvp) { 10ee40: 85 c0 test %eax,%eax <== NOT EXECUTED 10ee42: 74 15 je 10ee59 <_RTEMS_tasks_Delete_extension+0x31> <== NOT EXECUTED next = (rtems_task_variable_t *)tvp->next; 10ee44: 8b 18 mov (%eax),%ebx <== NOT EXECUTED _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); 10ee46: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ee49: 50 push %eax <== NOT EXECUTED 10ee4a: 56 push %esi <== NOT EXECUTED 10ee4b: e8 c8 00 00 00 call 10ef18 <_RTEMS_Tasks_Invoke_task_variable_dtor> <== NOT EXECUTED 10ee50: 89 d8 mov %ebx,%eax <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 10ee52: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ee55: 85 db test %ebx,%ebx <== NOT EXECUTED 10ee57: 75 eb jne 10ee44 <_RTEMS_tasks_Delete_extension+0x1c> <== NOT EXECUTED /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); 10ee59: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ee5c: ff b6 f4 00 00 00 pushl 0xf4(%esi) <== NOT EXECUTED 10ee62: e8 5d e5 ff ff call 10d3c4 <_Workspace_Free> <== NOT EXECUTED deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 10ee67: c7 86 f4 00 00 00 00 movl $0x0,0xf4(%esi) <== NOT EXECUTED 10ee6e: 00 00 00 <== NOT EXECUTED 10ee71: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10ee74: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ee77: 5b pop %ebx <== NOT EXECUTED 10ee78: 5e pop %esi <== NOT EXECUTED 10ee79: c9 leave <== NOT EXECUTED 10ee7a: c3 ret <== NOT EXECUTED 0010ed70 <_RTEMS_tasks_Initialize_user_tasks>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks( void ) { 10ed70: 55 push %ebp <== NOT EXECUTED 10ed71: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( _RTEMS_tasks_Initialize_user_tasks_p ) 10ed73: 8b 0d 0c a5 11 00 mov 0x11a50c,%ecx <== NOT EXECUTED 10ed79: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ed7b: 74 03 je 10ed80 <_RTEMS_tasks_Initialize_user_tasks+0x10> <== NOT EXECUTED (*_RTEMS_tasks_Initialize_user_tasks_p)(); } 10ed7d: c9 leave <== NOT EXECUTED */ void _RTEMS_tasks_Initialize_user_tasks( void ) { if ( _RTEMS_tasks_Initialize_user_tasks_p ) (*_RTEMS_tasks_Initialize_user_tasks_p)(); 10ed7e: ff e1 jmp *%ecx <== NOT EXECUTED } 10ed80: c9 leave <== NOT EXECUTED 10ed81: c3 ret <== NOT EXECUTED 0010a76c <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 10a76c: 55 push %ebp <== NOT EXECUTED 10a76d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a76f: 57 push %edi <== NOT EXECUTED 10a770: 56 push %esi <== NOT EXECUTED 10a771: 53 push %ebx <== NOT EXECUTED 10a772: 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; 10a775: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10a77a: 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; 10a77d: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED maximum = api_configuration->number_of_initialization_tasks; 10a780: 8b 78 28 mov 0x28(%eax),%edi <== NOT EXECUTED if ( !user_tasks || maximum == 0 ) 10a783: 85 d2 test %edx,%edx <== NOT EXECUTED 10a785: 74 48 je 10a7cf <_RTEMS_tasks_Initialize_user_tasks_body+0x63> <== NOT EXECUTED 10a787: 85 ff test %edi,%edi <== NOT EXECUTED 10a789: 74 44 je 10a7cf <_RTEMS_tasks_Initialize_user_tasks_body+0x63> <== NOT EXECUTED 10a78b: 89 d3 mov %edx,%ebx <== NOT EXECUTED 10a78d: 31 f6 xor %esi,%esi <== NOT EXECUTED 10a78f: 90 nop <== NOT EXECUTED return; for ( index=0 ; index < maximum ; index++ ) { return_value = rtems_task_create( 10a790: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a793: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10a796: 50 push %eax <== NOT EXECUTED 10a797: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 10a79a: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 10a79d: ff 73 04 pushl 0x4(%ebx) <== NOT EXECUTED 10a7a0: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10a7a3: ff 33 pushl (%ebx) <== NOT EXECUTED 10a7a5: e8 9a fd ff ff call 10a544 <== NOT EXECUTED user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 10a7aa: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10a7ad: 85 c0 test %eax,%eax <== NOT EXECUTED 10a7af: 75 27 jne 10a7d8 <_RTEMS_tasks_Initialize_user_tasks_body+0x6c> <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); return_value = rtems_task_start( 10a7b1: 51 push %ecx <== NOT EXECUTED 10a7b2: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10a7b5: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10a7b8: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10a7bb: e8 24 00 00 00 call 10a7e4 <== NOT EXECUTED id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 10a7c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a7c3: 85 c0 test %eax,%eax <== NOT EXECUTED 10a7c5: 75 11 jne 10a7d8 <_RTEMS_tasks_Initialize_user_tasks_body+0x6c> <== NOT EXECUTED maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) return; for ( index=0 ; index < maximum ; index++ ) { 10a7c7: 46 inc %esi <== NOT EXECUTED 10a7c8: 83 c3 1c add $0x1c,%ebx <== NOT EXECUTED 10a7cb: 39 f7 cmp %esi,%edi <== NOT EXECUTED 10a7cd: 77 c1 ja 10a790 <_RTEMS_tasks_Initialize_user_tasks_body+0x24> <== NOT EXECUTED ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); } } 10a7cf: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a7d2: 5b pop %ebx <== NOT EXECUTED 10a7d3: 5e pop %esi <== NOT EXECUTED 10a7d4: 5f pop %edi <== NOT EXECUTED 10a7d5: c9 leave <== NOT EXECUTED 10a7d6: c3 ret <== NOT EXECUTED 10a7d7: 90 nop <== NOT EXECUTED user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 10a7d8: 52 push %edx <== NOT EXECUTED 10a7d9: 50 push %eax <== NOT EXECUTED 10a7da: 6a 01 push $0x1 <== NOT EXECUTED 10a7dc: 6a 01 push $0x1 <== NOT EXECUTED 10a7de: e8 f9 0c 00 00 call 10b4dc <_Internal_error_Occurred> <== NOT EXECUTED 0010ed84 <_RTEMS_tasks_Manager_initialization>: */ void _RTEMS_tasks_Manager_initialization( uint32_t maximum_tasks ) { 10ed84: 55 push %ebp <== NOT EXECUTED 10ed85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ed87: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ed8a: 6a 04 push $0x4 <== NOT EXECUTED 10ed8c: 6a 00 push $0x0 <== NOT EXECUTED 10ed8e: 68 08 01 00 00 push $0x108 <== NOT EXECUTED 10ed93: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ed96: 6a 01 push $0x1 <== NOT EXECUTED 10ed98: 6a 02 push $0x2 <== NOT EXECUTED 10ed9a: 68 80 e9 11 00 push $0x11e980 <== NOT EXECUTED 10ed9f: e8 24 cd ff ff call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED /* * Add all the extensions for this API */ _User_extensions_Add_API_set( &_RTEMS_tasks_User_extensions ); 10eda4: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10eda7: 68 80 c8 11 00 push $0x11c880 <== NOT EXECUTED 10edac: e8 73 0a 00 00 call 10f824 <_User_extensions_Add_API_set> <== NOT EXECUTED _API_extensions_Add( &_RTEMS_tasks_API_extensions ); 10edb1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10edb4: c7 45 08 60 c8 11 00 movl $0x11c860,0x8(%ebp) <== NOT EXECUTED MP_PACKET_TASKS, _RTEMS_tasks_MP_Process_packet ); #endif } 10edbb: 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 ); 10edbc: e9 8f be ff ff jmp 10ac50 <_API_extensions_Add> <== NOT EXECUTED 0010edc4 <_RTEMS_tasks_Post_switch_extension>: */ void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) { 10edc4: 55 push %ebp <== NOT EXECUTED 10edc5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10edc7: 57 push %edi <== NOT EXECUTED 10edc8: 56 push %esi <== NOT EXECUTED 10edc9: 53 push %ebx <== NOT EXECUTED 10edca: 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 ]; 10edcd: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10edd0: 8b b0 f4 00 00 00 mov 0xf4(%eax),%esi <== NOT EXECUTED if ( !api ) 10edd6: 85 f6 test %esi,%esi <== NOT EXECUTED 10edd8: 74 45 je 10ee1f <_RTEMS_tasks_Post_switch_extension+0x5b> <== NOT EXECUTED * Signal Processing */ asr = &api->Signal; _ISR_Disable( level ); 10edda: 9c pushf <== NOT EXECUTED 10eddb: fa cli <== NOT EXECUTED 10eddc: 58 pop %eax <== NOT EXECUTED signal_set = asr->signals_posted; 10eddd: 8b 7e 14 mov 0x14(%esi),%edi <== NOT EXECUTED asr->signals_posted = 0; 10ede0: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED _ISR_Enable( level ); 10ede7: 50 push %eax <== NOT EXECUTED 10ede8: 9d popf <== NOT EXECUTED if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 10ede9: 85 ff test %edi,%edi <== NOT EXECUTED 10edeb: 74 32 je 10ee1f <_RTEMS_tasks_Post_switch_extension+0x5b> <== NOT EXECUTED return; asr->nest_level += 1; 10eded: ff 46 1c incl 0x1c(%esi) <== NOT EXECUTED rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10edf0: 50 push %eax <== NOT EXECUTED 10edf1: 8d 5d f0 lea -0x10(%ebp),%ebx <== NOT EXECUTED 10edf4: 53 push %ebx <== NOT EXECUTED 10edf5: 68 ff ff 00 00 push $0xffff <== NOT EXECUTED 10edfa: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 10edfd: e8 e6 0e 00 00 call 10fce8 <== NOT EXECUTED (*asr->handler)( signal_set ); 10ee02: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10ee05: ff 56 0c call *0xc(%esi) <== NOT EXECUTED asr->nest_level -= 1; 10ee08: ff 4e 1c decl 0x1c(%esi) <== NOT EXECUTED rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10ee0b: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ee0e: 53 push %ebx <== NOT EXECUTED 10ee0f: 68 ff ff 00 00 push $0xffff <== NOT EXECUTED 10ee14: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10ee17: e8 cc 0e 00 00 call 10fce8 <== NOT EXECUTED 10ee1c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10ee1f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ee22: 5b pop %ebx <== NOT EXECUTED 10ee23: 5e pop %esi <== NOT EXECUTED 10ee24: 5f pop %edi <== NOT EXECUTED 10ee25: c9 leave <== NOT EXECUTED 10ee26: c3 ret <== NOT EXECUTED 0010ed14 <_RTEMS_tasks_Start_extension>: User_extensions_routine _RTEMS_tasks_Start_extension( Thread_Control *executing, Thread_Control *started ) { 10ed14: 55 push %ebp <== NOT EXECUTED 10ed15: 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; 10ed17: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ed1a: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10ed20: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED } 10ed26: c9 leave <== NOT EXECUTED 10ed27: c3 ret <== NOT EXECUTED 0010ed28 <_RTEMS_tasks_Switch_extension>: void _RTEMS_tasks_Switch_extension( Thread_Control *executing, Thread_Control *heir ) { 10ed28: 55 push %ebp <== NOT EXECUTED 10ed29: 89 e5 mov %esp,%ebp <== NOT EXECUTED /* * Per Task Variables */ tvp = executing->task_variables; 10ed2b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ed2e: 8b 88 04 01 00 00 mov 0x104(%eax),%ecx <== NOT EXECUTED while (tvp) { 10ed34: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ed36: 74 13 je 10ed4b <_RTEMS_tasks_Switch_extension+0x23> <== NOT EXECUTED tvp->tval = *tvp->ptr; 10ed38: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10ed3b: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10ed3d: 89 51 0c mov %edx,0xc(%ecx) <== NOT EXECUTED *tvp->ptr = tvp->gval; 10ed40: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED 10ed43: 89 10 mov %edx,(%eax) <== NOT EXECUTED tvp = (rtems_task_variable_t *)tvp->next; 10ed45: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED /* * Per Task Variables */ tvp = executing->task_variables; while (tvp) { 10ed47: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ed49: 75 ed jne 10ed38 <_RTEMS_tasks_Switch_extension+0x10> <== NOT EXECUTED tvp->tval = *tvp->ptr; *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; 10ed4b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ed4e: 8b 88 04 01 00 00 mov 0x104(%eax),%ecx <== NOT EXECUTED while (tvp) { 10ed54: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ed56: 74 13 je 10ed6b <_RTEMS_tasks_Switch_extension+0x43> <== NOT EXECUTED tvp->gval = *tvp->ptr; 10ed58: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10ed5b: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10ed5d: 89 51 08 mov %edx,0x8(%ecx) <== NOT EXECUTED *tvp->ptr = tvp->tval; 10ed60: 8b 51 0c mov 0xc(%ecx),%edx <== NOT EXECUTED 10ed63: 89 10 mov %edx,(%eax) <== NOT EXECUTED tvp = (rtems_task_variable_t *)tvp->next; 10ed65: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { 10ed67: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ed69: 75 ed jne 10ed58 <_RTEMS_tasks_Switch_extension+0x30> <== NOT EXECUTED tvp->gval = *tvp->ptr; *tvp->ptr = tvp->tval; tvp = (rtems_task_variable_t *)tvp->next; } } 10ed6b: c9 leave <== NOT EXECUTED 10ed6c: c3 ret <== NOT EXECUTED 0010b0ac <_Rate_monotonic_Initiate_statistics>: #endif void _Rate_monotonic_Initiate_statistics( Rate_monotonic_Control *the_period ) { 10b0ac: 55 push %ebp <== NOT EXECUTED 10b0ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b0af: 57 push %edi <== NOT EXECUTED 10b0b0: 56 push %esi <== NOT EXECUTED 10b0b1: 53 push %ebx <== NOT EXECUTED 10b0b2: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 10b0b5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Thread_Control *owning_thread = the_period->owner; 10b0b8: 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 ); 10b0bb: 8d 7d ec lea -0x14(%ebp),%edi <== NOT EXECUTED 10b0be: 57 push %edi <== NOT EXECUTED 10b0bf: e8 6c 19 00 00 call 10ca30 <_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; 10b0c4: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10b0c7: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10b0ca: 89 46 44 mov %eax,0x44(%esi) <== NOT EXECUTED 10b0cd: 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; 10b0d0: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx <== NOT EXECUTED 10b0d6: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax <== NOT EXECUTED 10b0dc: 89 46 40 mov %eax,0x40(%esi) <== NOT EXECUTED 10b0df: 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) { 10b0e2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b0e5: 3b 1d 3c 28 12 00 cmp 0x12283c,%ebx <== NOT EXECUTED 10b0eb: 74 0b je 10b0f8 <_Rate_monotonic_Initiate_statistics+0x4c> <== NOT EXECUTED ); _Timespec_Add_to( &the_period->owner_executed_at_period, &ran ); } #endif } 10b0ed: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b0f0: 5b pop %ebx <== NOT EXECUTED 10b0f1: 5e pop %esi <== NOT EXECUTED 10b0f2: 5f pop %edi <== NOT EXECUTED 10b0f3: c9 leave <== NOT EXECUTED 10b0f4: c3 ret <== NOT EXECUTED 10b0f5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Adjust the CPU time used to account for the time since last * context switch. */ _Timespec_Subtract( 10b0f8: 51 push %ecx <== NOT EXECUTED 10b0f9: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED 10b0fc: 53 push %ebx <== NOT EXECUTED 10b0fd: 57 push %edi <== NOT EXECUTED 10b0fe: 68 44 28 12 00 push $0x122844 <== NOT EXECUTED 10b103: e8 04 39 00 00 call 10ea0c <_Timespec_Subtract> <== NOT EXECUTED &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timespec_Add_to( &the_period->owner_executed_at_period, &ran ); 10b108: 58 pop %eax <== NOT EXECUTED 10b109: 5a pop %edx <== NOT EXECUTED 10b10a: 53 push %ebx <== NOT EXECUTED 10b10b: 8d 46 3c lea 0x3c(%esi),%eax <== NOT EXECUTED 10b10e: 50 push %eax <== NOT EXECUTED 10b10f: e8 04 38 00 00 call 10e918 <_Timespec_Add_to> <== NOT EXECUTED 10b114: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b117: eb d4 jmp 10b0ed <_Rate_monotonic_Initiate_statistics+0x41> <== NOT EXECUTED 0010ec60 <_Rate_monotonic_Manager_initialization>: */ void _Rate_monotonic_Manager_initialization( uint32_t maximum_periods ) { 10ec60: 55 push %ebp <== NOT EXECUTED 10ec61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ec63: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ec66: 6a 04 push $0x4 <== NOT EXECUTED 10ec68: 6a 00 push $0x0 <== NOT EXECUTED 10ec6a: 68 8c 00 00 00 push $0x8c <== NOT EXECUTED 10ec6f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ec72: 6a 08 push $0x8 <== NOT EXECUTED 10ec74: 6a 02 push $0x2 <== NOT EXECUTED 10ec76: 68 80 ee 11 00 push $0x11ee80 <== NOT EXECUTED 10ec7b: e8 48 ce ff ff call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10ec80: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ec83: c9 leave <== NOT EXECUTED 10ec84: c3 ret <== NOT EXECUTED 0010b6e0 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 10b6e0: 55 push %ebp <== NOT EXECUTED 10b6e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b6e3: 53 push %ebx <== NOT EXECUTED 10b6e4: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10b6e7: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10b6ea: 50 push %eax <== NOT EXECUTED 10b6eb: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b6ee: 68 80 26 12 00 push $0x122680 <== NOT EXECUTED 10b6f3: e8 a4 1c 00 00 call 10d39c <_Objects_Get> <== NOT EXECUTED 10b6f8: 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 ) { 10b6fa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b6fd: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10b700: 85 c0 test %eax,%eax <== NOT EXECUTED 10b702: 75 21 jne 10b725 <_Rate_monotonic_Timeout+0x45> <== NOT EXECUTED case OBJECTS_LOCAL: the_thread = the_period->owner; 10b704: 8b 53 50 mov 0x50(%ebx),%edx <== NOT EXECUTED if ( _States_Is_waiting_for_period( the_thread->current_state ) && 10b707: f6 42 11 40 testb $0x40,0x11(%edx) <== NOT EXECUTED 10b70b: 75 1f jne 10b72c <_Rate_monotonic_Timeout+0x4c> <== NOT EXECUTED _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 10b70d: 83 7b 38 01 cmpl $0x1,0x38(%ebx) <== NOT EXECUTED 10b711: 74 35 je 10b748 <_Rate_monotonic_Timeout+0x68> <== NOT EXECUTED _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else the_period->state = RATE_MONOTONIC_EXPIRED; 10b713: c7 43 38 04 00 00 00 movl $0x4,0x38(%ebx) <== NOT EXECUTED 10b71a: a1 78 27 12 00 mov 0x122778,%eax <== NOT EXECUTED 10b71f: 48 dec %eax <== NOT EXECUTED 10b720: a3 78 27 12 00 mov %eax,0x122778 <== NOT EXECUTED case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10b725: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b728: c9 leave <== NOT EXECUTED 10b729: c3 ret <== NOT EXECUTED 10b72a: 66 90 xchg %ax,%ax <== NOT EXECUTED the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: the_thread = the_period->owner; if ( _States_Is_waiting_for_period( the_thread->current_state ) && 10b72c: 8b 42 20 mov 0x20(%edx),%eax <== NOT EXECUTED 10b72f: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10b732: 75 d9 jne 10b70d <_Rate_monotonic_Timeout+0x2d> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10b734: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b737: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10b73c: 52 push %edx <== NOT EXECUTED 10b73d: e8 f6 20 00 00 call 10d838 <_Thread_Clear_state> <== NOT EXECUTED the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 10b742: 59 pop %ecx <== NOT EXECUTED 10b743: eb 0d jmp 10b752 <_Rate_monotonic_Timeout+0x72> <== NOT EXECUTED 10b745: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 10b748: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) <== NOT EXECUTED _Rate_monotonic_Initiate_statistics( the_period ); 10b74f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b752: 53 push %ebx <== NOT EXECUTED 10b753: e8 54 f9 ff ff call 10b0ac <_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, 10b758: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 10b75b: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10b75e: 58 pop %eax <== NOT EXECUTED 10b75f: 5a pop %edx <== NOT EXECUTED 10b760: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10b763: 50 push %eax <== NOT EXECUTED 10b764: 68 5c 28 12 00 push $0x12285c <== NOT EXECUTED 10b769: e8 46 35 00 00 call 10ecb4 <_Watchdog_Insert> <== NOT EXECUTED 10b76e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b771: eb a7 jmp 10b71a <_Rate_monotonic_Timeout+0x3a> <== NOT EXECUTED 0010b11c <_Rate_monotonic_Update_statistics>: } void _Rate_monotonic_Update_statistics( Rate_monotonic_Control *the_period ) { 10b11c: 55 push %ebp <== NOT EXECUTED 10b11d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b11f: 57 push %edi <== NOT EXECUTED 10b120: 56 push %esi <== NOT EXECUTED 10b121: 53 push %ebx <== NOT EXECUTED 10b122: 83 ec 48 sub $0x48,%esp <== NOT EXECUTED 10b125: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED struct timespec uptime; /* * Obtain the current time since boot */ _TOD_Get_uptime( &uptime ); 10b128: 8d 7d dc lea -0x24(%ebp),%edi <== NOT EXECUTED 10b12b: 57 push %edi <== NOT EXECUTED 10b12c: e8 ff 18 00 00 call 10ca30 <_TOD_Get_uptime> <== NOT EXECUTED /* * Update the counts. */ stats = &the_period->Statistics; stats->count++; 10b131: ff 46 54 incl 0x54(%esi) <== NOT EXECUTED if ( the_period->state == RATE_MONOTONIC_EXPIRED ) 10b134: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b137: 83 7e 38 04 cmpl $0x4,0x38(%esi) <== NOT EXECUTED 10b13b: 0f 84 27 01 00 00 je 10b268 <_Rate_monotonic_Update_statistics+0x14c> <== NOT EXECUTED /* * Grab basic information for time statistics. */ #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 10b141: 50 push %eax <== NOT EXECUTED 10b142: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10b145: 50 push %eax <== NOT EXECUTED 10b146: 57 push %edi <== NOT EXECUTED 10b147: 8d 46 44 lea 0x44(%esi),%eax <== NOT EXECUTED 10b14a: 50 push %eax <== NOT EXECUTED 10b14b: e8 bc 38 00 00 call 10ea0c <_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; 10b150: a1 3c 28 12 00 mov 0x12283c,%eax <== NOT EXECUTED 10b155: 8b 90 84 00 00 00 mov 0x84(%eax),%edx <== NOT EXECUTED 10b15b: 8b 80 88 00 00 00 mov 0x88(%eax),%eax <== NOT EXECUTED 10b161: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 10b164: 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); 10b167: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10b16a: 8d 5d d4 lea -0x2c(%ebp),%ebx <== NOT EXECUTED 10b16d: 53 push %ebx <== NOT EXECUTED 10b16e: 57 push %edi <== NOT EXECUTED 10b16f: 68 44 28 12 00 push $0x122844 <== NOT EXECUTED 10b174: e8 93 38 00 00 call 10ea0c <_Timespec_Subtract> <== NOT EXECUTED /* executed += ran */ _Timespec_Add_to( &used, &ran ); 10b179: 59 pop %ecx <== NOT EXECUTED 10b17a: 5f pop %edi <== NOT EXECUTED 10b17b: 53 push %ebx <== NOT EXECUTED 10b17c: 8d 5d cc lea -0x34(%ebp),%ebx <== NOT EXECUTED 10b17f: 53 push %ebx <== NOT EXECUTED 10b180: e8 93 37 00 00 call 10e918 <_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)) 10b185: 8d 7e 3c lea 0x3c(%esi),%edi <== NOT EXECUTED 10b188: 58 pop %eax <== NOT EXECUTED 10b189: 5a pop %edx <== NOT EXECUTED 10b18a: 57 push %edi <== NOT EXECUTED 10b18b: 53 push %ebx <== NOT EXECUTED 10b18c: e8 57 38 00 00 call 10e9e8 <_Timespec_Less_than> <== NOT EXECUTED 10b191: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b194: 84 c0 test %al,%al <== NOT EXECUTED 10b196: 74 08 je 10b1a0 <_Rate_monotonic_Update_statistics+0x84> <== NOT EXECUTED stats->min_wall_time = since_last_period; if ( _Timespec_Greater_than( &since_last_period, &stats->max_wall_time ) ) stats->max_wall_time = since_last_period; #endif } 10b198: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b19b: 5b pop %ebx <== NOT EXECUTED 10b19c: 5e pop %esi <== NOT EXECUTED 10b19d: 5f pop %edi <== NOT EXECUTED 10b19e: c9 leave <== NOT EXECUTED 10b19f: c3 ret <== NOT EXECUTED /* partial period, cpu usage info reset while executing. Throw away */ if (_Timespec_Less_than( &used, &the_period->owner_executed_at_period)) return; /* executed = current cpu usage - value at start of period */ _Timespec_Subtract( 10b1a0: 50 push %eax <== NOT EXECUTED 10b1a1: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10b1a4: 50 push %eax <== NOT EXECUTED 10b1a5: 53 push %ebx <== NOT EXECUTED 10b1a6: 57 push %edi <== NOT EXECUTED 10b1a7: e8 60 38 00 00 call 10ea0c <_Timespec_Subtract> <== NOT EXECUTED /* * Update CPU time */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _Timespec_Add_to( &stats->total_cpu_time, &executed ); 10b1ac: 59 pop %ecx <== NOT EXECUTED 10b1ad: 5b pop %ebx <== NOT EXECUTED 10b1ae: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10b1b1: 50 push %eax <== NOT EXECUTED 10b1b2: 8d 46 6c lea 0x6c(%esi),%eax <== NOT EXECUTED 10b1b5: 50 push %eax <== NOT EXECUTED 10b1b6: e8 5d 37 00 00 call 10e918 <_Timespec_Add_to> <== NOT EXECUTED if ( _Timespec_Less_than( &executed, &stats->min_cpu_time ) ) 10b1bb: 58 pop %eax <== NOT EXECUTED 10b1bc: 5a pop %edx <== NOT EXECUTED 10b1bd: 8d 46 5c lea 0x5c(%esi),%eax <== NOT EXECUTED 10b1c0: 50 push %eax <== NOT EXECUTED 10b1c1: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10b1c4: 50 push %eax <== NOT EXECUTED 10b1c5: e8 1e 38 00 00 call 10e9e8 <_Timespec_Less_than> <== NOT EXECUTED 10b1ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b1cd: 84 c0 test %al,%al <== NOT EXECUTED 10b1cf: 74 0c je 10b1dd <_Rate_monotonic_Update_statistics+0xc1> <== NOT EXECUTED stats->min_cpu_time = executed; 10b1d1: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10b1d4: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10b1d7: 89 46 5c mov %eax,0x5c(%esi) <== NOT EXECUTED 10b1da: 89 56 60 mov %edx,0x60(%esi) <== NOT EXECUTED if ( _Timespec_Greater_than( &executed, &stats->max_cpu_time ) ) 10b1dd: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b1e0: 8d 46 64 lea 0x64(%esi),%eax <== NOT EXECUTED 10b1e3: 50 push %eax <== NOT EXECUTED 10b1e4: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10b1e7: 50 push %eax <== NOT EXECUTED 10b1e8: e8 d7 37 00 00 call 10e9c4 <_Timespec_Greater_than> <== NOT EXECUTED 10b1ed: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b1f0: 84 c0 test %al,%al <== NOT EXECUTED 10b1f2: 74 0c je 10b200 <_Rate_monotonic_Update_statistics+0xe4> <== NOT EXECUTED stats->max_cpu_time = executed; 10b1f4: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10b1f7: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10b1fa: 89 46 64 mov %eax,0x64(%esi) <== NOT EXECUTED 10b1fd: 89 56 68 mov %edx,0x68(%esi) <== 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 ); 10b200: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b203: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10b206: 50 push %eax <== NOT EXECUTED 10b207: 8d 86 84 00 00 00 lea 0x84(%esi),%eax <== NOT EXECUTED 10b20d: 50 push %eax <== NOT EXECUTED 10b20e: e8 05 37 00 00 call 10e918 <_Timespec_Add_to> <== NOT EXECUTED if ( _Timespec_Less_than( &since_last_period, &stats->min_wall_time ) ) 10b213: 5b pop %ebx <== NOT EXECUTED 10b214: 5f pop %edi <== NOT EXECUTED 10b215: 8d 46 74 lea 0x74(%esi),%eax <== NOT EXECUTED 10b218: 50 push %eax <== NOT EXECUTED 10b219: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10b21c: 50 push %eax <== NOT EXECUTED 10b21d: e8 c6 37 00 00 call 10e9e8 <_Timespec_Less_than> <== NOT EXECUTED 10b222: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b225: 84 c0 test %al,%al <== NOT EXECUTED 10b227: 74 0c je 10b235 <_Rate_monotonic_Update_statistics+0x119> <== NOT EXECUTED stats->min_wall_time = since_last_period; 10b229: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10b22c: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10b22f: 89 46 74 mov %eax,0x74(%esi) <== NOT EXECUTED 10b232: 89 56 78 mov %edx,0x78(%esi) <== NOT EXECUTED if ( _Timespec_Greater_than( &since_last_period, &stats->max_wall_time ) ) 10b235: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b238: 8d 46 7c lea 0x7c(%esi),%eax <== NOT EXECUTED 10b23b: 50 push %eax <== NOT EXECUTED 10b23c: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10b23f: 50 push %eax <== NOT EXECUTED 10b240: e8 7f 37 00 00 call 10e9c4 <_Timespec_Greater_than> <== NOT EXECUTED 10b245: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b248: 84 c0 test %al,%al <== NOT EXECUTED 10b24a: 0f 84 48 ff ff ff je 10b198 <_Rate_monotonic_Update_statistics+0x7c> <== NOT EXECUTED stats->max_wall_time = since_last_period; 10b250: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10b253: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10b256: 89 46 7c mov %eax,0x7c(%esi) <== NOT EXECUTED 10b259: 89 96 80 00 00 00 mov %edx,0x80(%esi) <== NOT EXECUTED #endif } 10b25f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b262: 5b pop %ebx <== NOT EXECUTED 10b263: 5e pop %esi <== NOT EXECUTED 10b264: 5f pop %edi <== NOT EXECUTED 10b265: c9 leave <== NOT EXECUTED 10b266: c3 ret <== NOT EXECUTED 10b267: 90 nop <== NOT EXECUTED */ stats = &the_period->Statistics; stats->count++; if ( the_period->state == RATE_MONOTONIC_EXPIRED ) stats->missed_count++; 10b268: ff 46 58 incl 0x58(%esi) <== NOT EXECUTED 10b26b: e9 d1 fe ff ff jmp 10b141 <_Rate_monotonic_Update_statistics+0x25> <== NOT EXECUTED 0010ec88 <_Region_Manager_initialization>: */ void _Region_Manager_initialization( uint32_t maximum_regions ) { 10ec88: 55 push %ebp <== NOT EXECUTED 10ec89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ec8b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ec8e: 6a 04 push $0x4 <== NOT EXECUTED 10ec90: 6a 00 push $0x0 <== NOT EXECUTED 10ec92: 68 c0 00 00 00 push $0xc0 <== NOT EXECUTED 10ec97: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ec9a: 6a 06 push $0x6 <== NOT EXECUTED 10ec9c: 6a 02 push $0x2 <== NOT EXECUTED 10ec9e: 68 c0 ee 11 00 push $0x11eec0 <== NOT EXECUTED 10eca3: e8 20 ce ff ff call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10eca8: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_REGION, 0 /* XXX _Region_MP_Process_packet */ ); #endif } 10ecab: c9 leave <== NOT EXECUTED 10ecac: c3 ret <== NOT EXECUTED 0011a24c <_Region_Process_queue>: */ void _Region_Process_queue( Region_Control *the_region ) { 11a24c: 55 push %ebp <== NOT EXECUTED 11a24d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11a24f: 57 push %edi <== NOT EXECUTED 11a250: 56 push %esi <== NOT EXECUTED 11a251: 53 push %ebx <== NOT EXECUTED 11a252: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 11a255: 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 11a258: a1 f8 5a 13 00 mov 0x135af8,%eax <== NOT EXECUTED 11a25d: 40 inc %eax <== NOT EXECUTED 11a25e: a3 f8 5a 13 00 mov %eax,0x135af8 <== 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(); 11a263: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 11a269: e8 c6 b1 ff ff call 115434 <_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 ); 11a26e: 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. * 11a271: 8d 46 68 lea 0x68(%esi),%eax <== NOT EXECUTED 11a274: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 11a277: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11a27a: eb 33 jmp 11a2af <_Region_Process_queue+0x63> <== NOT EXECUTED 11a27c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11a27f: ff 70 24 pushl 0x24(%eax) <== NOT EXECUTED 11a282: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 11a285: e8 9e bb ff ff call 115e28 <_Heap_Allocate> <== NOT EXECUTED 11a28a: 89 c2 mov %eax,%edx <== NOT EXECUTED the_segment = (void **) _Region_Allocate_segment( the_region, the_thread->Wait.count ); if ( the_segment == NULL ) 11a28c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11a28f: 85 c0 test %eax,%eax <== NOT EXECUTED 11a291: 74 2e je 11a2c1 <_Region_Process_queue+0x75> <== NOT EXECUTED break; *(void **)the_thread->Wait.return_argument = the_segment; 11a293: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 11a296: 89 10 mov %edx,(%eax) <== NOT EXECUTED the_region->number_of_used_blocks += 1; 11a298: ff 46 64 incl 0x64(%esi) <== NOT EXECUTED _Thread_queue_Extract( &the_region->Wait_queue, the_thread ); 11a29b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11a29e: 53 push %ebx <== NOT EXECUTED 11a29f: 57 push %edi <== NOT EXECUTED 11a2a0: e8 47 06 00 00 call 11a8ec <_Thread_queue_Extract> <== NOT EXECUTED the_thread->Wait.return_code = RTEMS_SUCCESSFUL; 11a2a5: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED 11a2ac: 83 c4 10 add $0x10,%esp <== 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 ); 11a2af: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11a2b2: 57 push %edi <== NOT EXECUTED 11a2b3: e8 28 07 00 00 call 11a9e0 <_Thread_queue_First> <== NOT EXECUTED 11a2b8: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( the_thread == NULL ) 11a2ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11a2bd: 85 c0 test %eax,%eax <== NOT EXECUTED 11a2bf: 75 bb jne 11a27c <_Region_Process_queue+0x30> <== NOT EXECUTED 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(); } 11a2c1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11a2c4: 5b pop %ebx <== NOT EXECUTED 11a2c5: 5e pop %esi <== NOT EXECUTED 11a2c6: 5f pop %edi <== NOT EXECUTED 11a2c7: 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(); 11a2c8: e9 13 d1 ff ff jmp 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 0010ece8 <_Semaphore_Manager_initialization>: */ void _Semaphore_Manager_initialization( uint32_t maximum_semaphores ) { 10ece8: 55 push %ebp <== NOT EXECUTED 10ece9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10eceb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ecee: 6a 04 push $0x4 <== NOT EXECUTED 10ecf0: 6a 00 push $0x0 <== NOT EXECUTED 10ecf2: 6a 78 push $0x78 <== NOT EXECUTED 10ecf4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ecf7: 6a 03 push $0x3 <== NOT EXECUTED 10ecf9: 6a 02 push $0x2 <== NOT EXECUTED 10ecfb: 68 40 e9 11 00 push $0x11e940 <== NOT EXECUTED 10ed00: e8 c3 cd ff ff call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10ed05: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_SEMAPHORE, _Semaphore_MP_Process_packet ); #endif } 10ed08: c9 leave <== NOT EXECUTED 10ed09: c3 ret <== NOT EXECUTED 0010a524 <_Semaphore_Translate_core_mutex_return_code>: }; rtems_status_code _Semaphore_Translate_core_mutex_return_code ( uint32_t status ) { 10a524: 55 push %ebp <== NOT EXECUTED 10a525: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a527: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a52a: 8b 04 85 1c 85 11 00 mov 0x11851c(,%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]; } 10a531: c9 leave <== NOT EXECUTED 10a532: c3 ret <== NOT EXECUTED 0010a534 <_Semaphore_Translate_core_semaphore_return_code>: }; rtems_status_code _Semaphore_Translate_core_semaphore_return_code ( uint32_t status ) { 10a534: 55 push %ebp <== NOT EXECUTED 10a535: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a537: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a53a: 8b 04 85 38 85 11 00 mov 0x118538(,%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]; } 10a541: c9 leave <== NOT EXECUTED 10a542: c3 ret <== NOT EXECUTED 0010ed0c <_Signal_Manager_initialization>: * * Output parameters: NONE */ void _Signal_Manager_initialization( void ) { 10ed0c: 55 push %ebp <== NOT EXECUTED 10ed0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED _MPCI_Register_packet_processor( MP_PACKET_SIGNAL, _Signal_MP_Process_packet ); #endif } 10ed0f: c9 leave <== NOT EXECUTED 10ed10: c3 ret <== NOT EXECUTED 0010b1f8 <_TOD_Get>: */ void _TOD_Get( struct timespec *time ) { 10b1f8: 55 push %ebp <== NOT EXECUTED 10b1f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b1fb: 56 push %esi <== NOT EXECUTED 10b1fc: 53 push %ebx <== NOT EXECUTED 10b1fd: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10b200: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED ISR_Level level; struct timespec offset; /* assume time checked by caller */ offset.tv_sec = 0; 10b203: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED offset.tv_nsec = 0; 10b20a: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED /* _TOD_Now is a proper POSIX time */ _ISR_Disable( level ); 10b211: 9c pushf <== NOT EXECUTED 10b212: fa cli <== NOT EXECUTED 10b213: 5b pop %ebx <== NOT EXECUTED *time = _TOD_Now; 10b214: a1 8c ea 11 00 mov 0x11ea8c,%eax <== NOT EXECUTED 10b219: 8b 15 90 ea 11 00 mov 0x11ea90,%edx <== NOT EXECUTED 10b21f: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10b221: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED if ( _Watchdog_Nanoseconds_since_tick_handler ) 10b224: a1 c8 eb 11 00 mov 0x11ebc8,%eax <== NOT EXECUTED 10b229: 85 c0 test %eax,%eax <== NOT EXECUTED 10b22b: 74 05 je 10b232 <_TOD_Get+0x3a> <== NOT EXECUTED offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)(); 10b22d: ff d0 call *%eax <== NOT EXECUTED 10b22f: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED _ISR_Enable( level ); 10b232: 53 push %ebx <== NOT EXECUTED 10b233: 9d popf <== NOT EXECUTED _Timespec_Add_to( time, &offset ); 10b234: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b237: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b23a: 50 push %eax <== NOT EXECUTED 10b23b: 56 push %esi <== NOT EXECUTED 10b23c: e8 97 1c 00 00 call 10ced8 <_Timespec_Add_to> <== NOT EXECUTED 10b241: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b244: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b247: 5b pop %ebx <== NOT EXECUTED 10b248: 5e pop %esi <== NOT EXECUTED 10b249: c9 leave <== NOT EXECUTED 10b24a: c3 ret <== NOT EXECUTED 0010f20c <_TOD_Get_uptime>: */ void _TOD_Get_uptime( struct timespec *uptime ) { 10f20c: 55 push %ebp <== NOT EXECUTED 10f20d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f20f: 56 push %esi <== NOT EXECUTED 10f210: 53 push %ebx <== NOT EXECUTED 10f211: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10f214: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED ISR_Level level; struct timespec offset; /* assume uptime checked by caller */ offset.tv_sec = 0; 10f217: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED offset.tv_nsec = 0; 10f21e: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED _ISR_Disable( level ); 10f225: 9c pushf <== NOT EXECUTED 10f226: fa cli <== NOT EXECUTED 10f227: 5b pop %ebx <== NOT EXECUTED *uptime = _TOD_Uptime; 10f228: a1 78 ea 11 00 mov 0x11ea78,%eax <== NOT EXECUTED 10f22d: 8b 15 7c ea 11 00 mov 0x11ea7c,%edx <== NOT EXECUTED 10f233: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10f235: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED if ( _Watchdog_Nanoseconds_since_tick_handler ) 10f238: a1 c8 eb 11 00 mov 0x11ebc8,%eax <== NOT EXECUTED 10f23d: 85 c0 test %eax,%eax <== NOT EXECUTED 10f23f: 74 05 je 10f246 <_TOD_Get_uptime+0x3a> <== NOT EXECUTED offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)(); 10f241: ff d0 call *%eax <== NOT EXECUTED 10f243: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED _ISR_Enable( level ); 10f246: 53 push %ebx <== NOT EXECUTED 10f247: 9d popf <== NOT EXECUTED _Timespec_Add_to( uptime, &offset ); 10f248: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f24b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10f24e: 50 push %eax <== NOT EXECUTED 10f24f: 56 push %esi <== NOT EXECUTED 10f250: e8 83 dc ff ff call 10ced8 <_Timespec_Add_to> <== NOT EXECUTED 10f255: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10f258: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f25b: 5b pop %ebx <== NOT EXECUTED 10f25c: 5e pop %esi <== NOT EXECUTED 10f25d: c9 leave <== NOT EXECUTED 10f25e: c3 ret <== NOT EXECUTED 0010b24c <_TOD_Handler_initialization>: */ void _TOD_Handler_initialization( uint32_t microseconds_per_tick ) { 10b24c: 55 push %ebp <== NOT EXECUTED 10b24d: 89 e5 mov %esp,%ebp <== NOT EXECUTED _TOD_Microseconds_per_tick = microseconds_per_tick; 10b24f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b252: a3 c0 eb 11 00 mov %eax,0x11ebc0 <== NOT EXECUTED /* POSIX format TOD (timespec) */ _TOD_Now.tv_sec = TOD_SECONDS_1970_THROUGH_1988; 10b257: c7 05 8c ea 11 00 00 movl $0x21dae500,0x11ea8c <== NOT EXECUTED 10b25e: e5 da 21 <== NOT EXECUTED _TOD_Now.tv_nsec = 0; 10b261: c7 05 90 ea 11 00 00 movl $0x0,0x11ea90 <== NOT EXECUTED 10b268: 00 00 00 <== NOT EXECUTED /* Uptime (timespec) */ _TOD_Uptime.tv_sec = 0; 10b26b: c7 05 78 ea 11 00 00 movl $0x0,0x11ea78 <== NOT EXECUTED 10b272: 00 00 00 <== NOT EXECUTED _TOD_Uptime.tv_nsec = 0; 10b275: c7 05 7c ea 11 00 00 movl $0x0,0x11ea7c <== NOT EXECUTED 10b27c: 00 00 00 <== NOT EXECUTED /* TOD has not been set */ _TOD_Is_set = FALSE; 10b27f: c6 05 0c ea 11 00 00 movb $0x0,0x11ea0c <== NOT EXECUTED _TOD_Activate(); } 10b286: c9 leave <== NOT EXECUTED 10b287: c3 ret <== NOT EXECUTED 0010c588 <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 10c588: 55 push %ebp <== NOT EXECUTED 10c589: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c58b: 53 push %ebx <== NOT EXECUTED 10c58c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10c58f: 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 10c592: a1 58 a5 12 00 mov 0x12a558,%eax <== NOT EXECUTED 10c597: 40 inc %eax <== NOT EXECUTED 10c598: a3 58 a5 12 00 mov %eax,0x12a558 <== NOT EXECUTED _Thread_Disable_dispatch(); _TOD_Deactivate(); if ( time->tv_sec < _TOD_Seconds_since_epoch ) 10c59d: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10c59f: a1 ec a5 12 00 mov 0x12a5ec,%eax <== NOT EXECUTED 10c5a4: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10c5a6: 7c 34 jl 10c5dc <_TOD_Set+0x54> <== NOT EXECUTED */ bool _Protected_heap_Free( Heap_Control *the_heap, void *start_address ); 10c5a8: 51 push %ecx <== NOT EXECUTED 10c5a9: 29 c2 sub %eax,%edx <== NOT EXECUTED 10c5ab: 52 push %edx <== NOT EXECUTED 10c5ac: 6a 00 push $0x0 <== NOT EXECUTED 10c5ae: 68 30 a6 12 00 push $0x12a630 <== NOT EXECUTED 10c5b3: e8 a8 23 00 00 call 10e960 <_Watchdog_Adjust> <== NOT EXECUTED 10c5b8: 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; 10c5bb: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10c5bd: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10c5c0: a3 f0 a5 12 00 mov %eax,0x12a5f0 <== NOT EXECUTED 10c5c5: 89 15 ec a5 12 00 mov %edx,0x12a5ec <== NOT EXECUTED _TOD_Is_set = TRUE; 10c5cb: c6 05 6c a5 12 00 01 movb $0x1,0x12a56c <== NOT EXECUTED _TOD_Activate(); _Thread_Enable_dispatch(); } 10c5d2: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c5d5: c9 leave <== NOT EXECUTED _TOD_Now = *time; _TOD_Is_set = TRUE; _TOD_Activate(); _Thread_Enable_dispatch(); 10c5d6: e9 99 11 00 00 jmp 10d774 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c5db: 90 nop <== NOT EXECUTED 10c5dc: 51 push %ecx <== NOT EXECUTED 10c5dd: 29 d0 sub %edx,%eax <== NOT EXECUTED 10c5df: 50 push %eax <== NOT EXECUTED 10c5e0: 6a 01 push $0x1 <== NOT EXECUTED 10c5e2: 68 30 a6 12 00 push $0x12a630 <== NOT EXECUTED 10c5e7: e8 74 23 00 00 call 10e960 <_Watchdog_Adjust> <== NOT EXECUTED 10c5ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c5ef: eb ca jmp 10c5bb <_TOD_Set+0x33> <== NOT EXECUTED 0010b288 <_TOD_Tickle_ticks>: * * Output parameters: NONE */ void _TOD_Tickle_ticks( void ) { 10b288: 55 push %ebp <== NOT EXECUTED 10b289: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b28b: 53 push %ebx <== NOT EXECUTED 10b28c: 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; 10b28f: a1 c0 eb 11 00 mov 0x11ebc0,%eax <== NOT EXECUTED 10b294: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10b297: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10b29a: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10b29d: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED 10b2a0: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED tick.tv_sec = 0; 10b2a3: 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; 10b2aa: a1 64 eb 11 00 mov 0x11eb64,%eax <== NOT EXECUTED 10b2af: 40 inc %eax <== NOT EXECUTED 10b2b0: a3 64 eb 11 00 mov %eax,0x11eb64 <== NOT EXECUTED /* Update the timespec format uptime */ (void) _Timespec_Add_to( &_TOD_Uptime, &tick ); 10b2b5: 8d 5d f4 lea -0xc(%ebp),%ebx <== NOT EXECUTED 10b2b8: 53 push %ebx <== NOT EXECUTED 10b2b9: 68 78 ea 11 00 push $0x11ea78 <== NOT EXECUTED 10b2be: e8 15 1c 00 00 call 10ced8 <_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 ); 10b2c3: 58 pop %eax <== NOT EXECUTED 10b2c4: 5a pop %edx <== NOT EXECUTED 10b2c5: 53 push %ebx <== NOT EXECUTED 10b2c6: 68 8c ea 11 00 push $0x11ea8c <== NOT EXECUTED 10b2cb: e8 08 1c 00 00 call 10ced8 <_Timespec_Add_to> <== NOT EXECUTED 10b2d0: 89 c3 mov %eax,%ebx <== NOT EXECUTED while ( seconds ) { 10b2d2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b2d5: 85 c0 test %eax,%eax <== NOT EXECUTED 10b2d7: 74 16 je 10b2ef <_TOD_Tickle_ticks+0x67> <== NOT EXECUTED 10b2d9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ); 10b2dc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b2df: 68 d0 ea 11 00 push $0x11ead0 <== NOT EXECUTED 10b2e4: e8 6b 20 00 00 call 10d354 <_Watchdog_Tickle> <== NOT EXECUTED 10b2e9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b2ec: 4b dec %ebx <== NOT EXECUTED 10b2ed: 75 ed jne 10b2dc <_TOD_Tickle_ticks+0x54> <== NOT EXECUTED _Watchdog_Tickle_seconds(); seconds--; } } 10b2ef: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b2f2: c9 leave <== NOT EXECUTED 10b2f3: c3 ret <== NOT EXECUTED 0010ac20 <_TOD_To_seconds>: */ uint32_t _TOD_To_seconds( rtems_time_of_day *the_tod ) { 10ac20: 55 push %ebp <== NOT EXECUTED 10ac21: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac23: 57 push %edi <== NOT EXECUTED 10ac24: 56 push %esi <== NOT EXECUTED 10ac25: 53 push %ebx <== NOT EXECUTED 10ac26: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED uint32_t time; uint32_t year_mod_4; time = the_tod->day - 1; 10ac29: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10ac2c: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED year_mod_4 = the_tod->year & 3; 10ac2f: 8b 13 mov (%ebx),%edx <== NOT EXECUTED if ( year_mod_4 == 0 ) 10ac31: 89 d6 mov %edx,%esi <== NOT EXECUTED 10ac33: 83 e6 03 and $0x3,%esi <== NOT EXECUTED 10ac36: 74 68 je 10aca0 <_TOD_To_seconds+0x80> <== NOT EXECUTED time += _TOD_Days_to_date[ 1 ][ the_tod->month ]; else time += _TOD_Days_to_date[ 0 ][ the_tod->month ]; 10ac38: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10ac3b: 0f b7 84 00 40 b7 11 movzwl 0x11b740(%eax,%eax,1),%eax <== NOT EXECUTED 10ac42: 00 <== NOT EXECUTED 10ac43: 8d 3c 08 lea (%eax,%ecx,1),%edi <== NOT EXECUTED time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) * 10ac46: 0f b7 8c 36 74 b7 11 movzwl 0x11b774(%esi,%esi,1),%ecx <== NOT EXECUTED 10ac4d: 00 <== NOT EXECUTED 10ac4e: 81 ea c4 07 00 00 sub $0x7c4,%edx <== NOT EXECUTED 10ac54: c1 ea 02 shr $0x2,%edx <== NOT EXECUTED 10ac57: 8d 04 d2 lea (%edx,%edx,8),%eax <== NOT EXECUTED 10ac5a: 8d 04 c2 lea (%edx,%eax,8),%eax <== NOT EXECUTED 10ac5d: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10ac60: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 10ac63: 01 c1 add %eax,%ecx <== NOT EXECUTED ( (TOD_DAYS_PER_YEAR * 4) + 1); time += _TOD_Days_since_last_leap_year[ year_mod_4 ]; 10ac65: 01 f9 add %edi,%ecx <== NOT EXECUTED time *= TOD_SECONDS_PER_DAY; 10ac67: 8d 14 89 lea (%ecx,%ecx,4),%edx <== NOT EXECUTED 10ac6a: 8d 14 91 lea (%ecx,%edx,4),%edx <== NOT EXECUTED 10ac6d: 8d 14 d1 lea (%ecx,%edx,8),%edx <== NOT EXECUTED 10ac70: c1 e2 02 shl $0x2,%edx <== NOT EXECUTED 10ac73: 29 ca sub %ecx,%edx <== NOT EXECUTED 10ac75: c1 e2 07 shl $0x7,%edx <== NOT EXECUTED time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute) 10ac78: 8b 4b 14 mov 0x14(%ebx),%ecx <== NOT EXECUTED * TOD_SECONDS_PER_MINUTE; time += the_tod->second; 10ac7b: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10ac7e: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10ac81: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10ac84: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10ac87: 03 43 10 add 0x10(%ebx),%eax <== NOT EXECUTED 10ac8a: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10ac8d: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10ac90: 8d 84 81 00 e5 da 21 lea 0x21dae500(%ecx,%eax,4),%eax <== NOT EXECUTED 10ac97: 01 d0 add %edx,%eax <== NOT EXECUTED time += TOD_SECONDS_1970_THROUGH_1988; return( time ); } 10ac99: 5b pop %ebx <== NOT EXECUTED 10ac9a: 5e pop %esi <== NOT EXECUTED 10ac9b: 5f pop %edi <== NOT EXECUTED 10ac9c: c9 leave <== NOT EXECUTED 10ac9d: c3 ret <== NOT EXECUTED 10ac9e: 66 90 xchg %ax,%ax <== NOT EXECUTED time = the_tod->day - 1; year_mod_4 = the_tod->year & 3; if ( year_mod_4 == 0 ) time += _TOD_Days_to_date[ 1 ][ the_tod->month ]; 10aca0: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10aca3: 0f b7 84 00 5a b7 11 movzwl 0x11b75a(%eax,%eax,1),%eax <== NOT EXECUTED 10acaa: 00 <== NOT EXECUTED 10acab: 8d 3c 08 lea (%eax,%ecx,1),%edi <== NOT EXECUTED 10acae: eb 96 jmp 10ac46 <_TOD_To_seconds+0x26> <== NOT EXECUTED 0010acb0 <_TOD_Validate>: */ bool _TOD_Validate( rtems_time_of_day *the_tod ) { 10acb0: 55 push %ebp <== NOT EXECUTED 10acb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10acb3: 53 push %ebx <== NOT EXECUTED 10acb4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10acb7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED uint32_t days_in_month; if ((!the_tod) || 10acba: 85 db test %ebx,%ebx <== NOT EXECUTED 10acbc: 74 56 je 10ad14 <_TOD_Validate+0x64> <== NOT EXECUTED 10acbe: b8 40 42 0f 00 mov $0xf4240,%eax <== NOT EXECUTED 10acc3: 31 d2 xor %edx,%edx <== NOT EXECUTED 10acc5: f7 35 20 a7 12 00 divl 0x12a720 <== NOT EXECUTED 10accb: 39 43 18 cmp %eax,0x18(%ebx) <== NOT EXECUTED 10acce: 73 44 jae 10ad14 <_TOD_Validate+0x64> <== NOT EXECUTED 10acd0: 83 7b 14 3b cmpl $0x3b,0x14(%ebx) <== NOT EXECUTED 10acd4: 77 3e ja 10ad14 <_TOD_Validate+0x64> <== NOT EXECUTED 10acd6: 83 7b 10 3b cmpl $0x3b,0x10(%ebx) <== NOT EXECUTED 10acda: 77 38 ja 10ad14 <_TOD_Validate+0x64> <== NOT EXECUTED 10acdc: 83 7b 0c 17 cmpl $0x17,0xc(%ebx) <== NOT EXECUTED 10ace0: 77 32 ja 10ad14 <_TOD_Validate+0x64> <== NOT EXECUTED 10ace2: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10ace5: 85 c0 test %eax,%eax <== NOT EXECUTED 10ace7: 74 2b je 10ad14 <_TOD_Validate+0x64> <== NOT EXECUTED 10ace9: 83 f8 0c cmp $0xc,%eax <== NOT EXECUTED 10acec: 77 26 ja 10ad14 <_TOD_Validate+0x64> <== NOT EXECUTED 10acee: 8b 0b mov (%ebx),%ecx <== NOT EXECUTED 10acf0: 81 f9 c3 07 00 00 cmp $0x7c3,%ecx <== NOT EXECUTED 10acf6: 76 1c jbe 10ad14 <_TOD_Validate+0x64> <== NOT EXECUTED 10acf8: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10acfb: 85 d2 test %edx,%edx <== NOT EXECUTED 10acfd: 74 15 je 10ad14 <_TOD_Validate+0x64> <== 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 ) 10acff: 83 e1 03 and $0x3,%ecx <== NOT EXECUTED 10ad02: 75 16 jne 10ad1a <_TOD_Validate+0x6a> <== NOT EXECUTED days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 10ad04: 8b 04 85 b4 b7 11 00 mov 0x11b7b4(,%eax,4),%eax <== NOT EXECUTED else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 10ad0b: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10ad0d: 0f 93 c0 setae %al <== NOT EXECUTED 10ad10: eb 04 jmp 10ad16 <_TOD_Validate+0x66> <== NOT EXECUTED 10ad12: 66 90 xchg %ax,%ax <== NOT EXECUTED 10ad14: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( the_tod->day > days_in_month ) return false; return true; } 10ad16: 5a pop %edx <== NOT EXECUTED 10ad17: 5b pop %ebx <== NOT EXECUTED 10ad18: c9 leave <== NOT EXECUTED 10ad19: c3 ret <== NOT EXECUTED return false; if ( (the_tod->year % 4) == 0 ) days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 10ad1a: 8b 04 85 80 b7 11 00 mov 0x11b780(,%eax,4),%eax <== NOT EXECUTED 10ad21: eb e8 jmp 10ad0b <_TOD_Validate+0x5b> <== NOT EXECUTED 0010bdcc <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10bdcc: 55 push %ebp <== NOT EXECUTED 10bdcd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bdcf: 57 push %edi <== NOT EXECUTED 10bdd0: 56 push %esi <== NOT EXECUTED 10bdd1: 53 push %ebx <== NOT EXECUTED 10bdd2: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10bdd5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bdd8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10bddb: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 10bdde: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED */ /* * Save original state */ original_state = the_thread->current_state; 10bde1: 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 ); 10bde4: 53 push %ebx <== NOT EXECUTED 10bde5: e8 4a 0e 00 00 call 10cc34 <_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 ) 10bdea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bded: 39 73 14 cmp %esi,0x14(%ebx) <== NOT EXECUTED 10bdf0: 74 0d je 10bdff <_Thread_Change_priority+0x33> <== NOT EXECUTED _Thread_Set_priority( the_thread, new_priority ); 10bdf2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bdf5: 56 push %esi <== NOT EXECUTED 10bdf6: 53 push %ebx <== NOT EXECUTED 10bdf7: e8 f4 0c 00 00 call 10caf0 <_Thread_Set_priority> <== NOT EXECUTED 10bdfc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _ISR_Disable( level ); 10bdff: 9c pushf <== NOT EXECUTED 10be00: fa cli <== NOT EXECUTED 10be01: 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; 10be02: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED if ( state != STATES_TRANSIENT ) { 10be05: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10be08: 74 3a je 10be44 <_Thread_Change_priority+0x78> <== NOT EXECUTED /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10be0a: 83 e7 04 and $0x4,%edi <== NOT EXECUTED 10be0d: 75 08 jne 10be17 <_Thread_Change_priority+0x4b> <== NOT EXECUTED the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10be0f: 89 d0 mov %edx,%eax <== NOT EXECUTED 10be11: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 10be14: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10be17: 56 push %esi <== NOT EXECUTED 10be18: 9d popf <== NOT EXECUTED if ( _States_Is_waiting_on_thread_queue( state ) ) { 10be19: 81 e2 e0 be 03 00 and $0x3bee0,%edx <== NOT EXECUTED 10be1f: 75 0b jne 10be2c <_Thread_Change_priority+0x60> <== NOT EXECUTED if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10be21: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10be24: 5b pop %ebx <== NOT EXECUTED 10be25: 5e pop %esi <== NOT EXECUTED 10be26: 5f pop %edi <== NOT EXECUTED 10be27: c9 leave <== NOT EXECUTED 10be28: c3 ret <== NOT EXECUTED 10be29: 8d 76 00 lea 0x0(%esi),%esi <== 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 ); 10be2c: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 10be2f: 8b 43 44 mov 0x44(%ebx),%eax <== NOT EXECUTED 10be32: 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 ); } 10be35: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10be38: 5b pop %ebx <== NOT EXECUTED 10be39: 5e pop %esi <== NOT EXECUTED 10be3a: 5f pop %edi <== NOT EXECUTED 10be3b: 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 ); 10be3c: e9 1b 0c 00 00 jmp 10ca5c <_Thread_queue_Requeue> <== NOT EXECUTED 10be41: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10be44: 83 e7 04 and $0x4,%edi <== NOT EXECUTED 10be47: 75 41 jne 10be8a <_Thread_Change_priority+0xbe> <== 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 ); 10be49: 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 10be50: 8b 93 90 00 00 00 mov 0x90(%ebx),%edx <== NOT EXECUTED 10be56: 66 8b 83 96 00 00 00 mov 0x96(%ebx),%ax <== NOT EXECUTED 10be5d: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10be60: 66 a1 b0 ea 11 00 mov 0x11eab0,%ax <== NOT EXECUTED 10be66: 0b 83 94 00 00 00 or 0x94(%ebx),%eax <== NOT EXECUTED 10be6c: 66 a3 b0 ea 11 00 mov %ax,0x11eab0 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); if ( prepend_it ) 10be72: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10be76: 74 70 je 10bee8 <_Thread_Change_priority+0x11c> <== 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 10be78: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax <== NOT EXECUTED 10be7e: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED 10be81: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10be83: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10be85: 89 13 mov %edx,(%ebx) <== NOT EXECUTED 10be87: 89 5a 04 mov %ebx,0x4(%edx) <== 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 ); 10be8a: 56 push %esi <== NOT EXECUTED 10be8b: 9d popf <== NOT EXECUTED 10be8c: fa cli <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10be8d: 66 8b 0d b0 ea 11 00 mov 0x11eab0,%cx <== NOT EXECUTED 10be94: 31 d2 xor %edx,%edx <== NOT EXECUTED 10be96: 89 d0 mov %edx,%eax <== NOT EXECUTED 10be98: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10be9c: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10be9f: 66 8b 8c 00 40 eb 11 mov 0x11eb40(%eax,%eax,1),%cx <== NOT EXECUTED 10bea6: 00 <== NOT EXECUTED 10bea7: 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. 10beab: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10beae: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10beb1: 01 d0 add %edx,%eax <== NOT EXECUTED 10beb3: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10beb6: 8b 15 c0 e9 11 00 mov 0x11e9c0,%edx <== NOT EXECUTED 10bebc: 8b 04 82 mov (%edx,%eax,4),%eax <== NOT EXECUTED 10bebf: a3 88 ea 11 00 mov %eax,0x11ea88 <== NOT EXECUTED void *starting_address, size_t size ); /** * This function attempts to allocate a block of @a size bytes from 10bec4: 8b 15 bc ea 11 00 mov 0x11eabc,%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() && 10beca: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10becc: 74 0d je 10bedb <_Thread_Change_priority+0x10f> <== NOT EXECUTED 10bece: 80 7a 76 00 cmpb $0x0,0x76(%edx) <== NOT EXECUTED 10bed2: 74 07 je 10bedb <_Thread_Change_priority+0x10f> <== NOT EXECUTED _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; 10bed4: c6 05 cc ea 11 00 01 movb $0x1,0x11eacc <== NOT EXECUTED _ISR_Enable( level ); 10bedb: 56 push %esi <== NOT EXECUTED 10bedc: 9d popf <== NOT EXECUTED } 10bedd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bee0: 5b pop %ebx <== NOT EXECUTED 10bee1: 5e pop %esi <== NOT EXECUTED 10bee2: 5f pop %edi <== NOT EXECUTED 10bee3: c9 leave <== NOT EXECUTED 10bee4: c3 ret <== NOT EXECUTED 10bee5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); if ( prepend_it ) _Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node ); else _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node ); 10bee8: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax <== NOT EXECUTED 10beee: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10bef1: 89 13 mov %edx,(%ebx) <== NOT EXECUTED 10bef3: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10bef6: 89 58 08 mov %ebx,0x8(%eax) <== NOT EXECUTED 10bef9: 89 1a mov %ebx,(%edx) <== NOT EXECUTED 10befb: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED 10befe: eb 8a jmp 10be8a <_Thread_Change_priority+0xbe> <== NOT EXECUTED 0010bf00 <_Thread_Clear_state>: void _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) { 10bf00: 55 push %ebp <== NOT EXECUTED 10bf01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bf03: 53 push %ebx <== NOT EXECUTED 10bf04: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10bf07: 9c pushf <== NOT EXECUTED 10bf08: fa cli <== NOT EXECUTED 10bf09: 5b pop %ebx <== NOT EXECUTED current_state = the_thread->current_state; 10bf0a: 8b 51 10 mov 0x10(%ecx),%edx <== NOT EXECUTED if ( current_state & state ) { 10bf0d: 85 55 0c test %edx,0xc(%ebp) <== NOT EXECUTED 10bf10: 74 72 je 10bf84 <_Thread_Clear_state+0x84> <== 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( 10bf12: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10bf15: f7 d0 not %eax <== NOT EXECUTED 10bf17: 21 d0 and %edx,%eax <== NOT EXECUTED current_state = 10bf19: 89 41 10 mov %eax,0x10(%ecx) <== NOT EXECUTED the_thread->current_state = _States_Clear( state, current_state ); if ( _States_Is_ready( current_state ) ) { 10bf1c: 85 c0 test %eax,%eax <== NOT EXECUTED 10bf1e: 75 64 jne 10bf84 <_Thread_Clear_state+0x84> <== 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 10bf20: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10bf26: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10bf2d: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10bf30: 66 a1 b0 ea 11 00 mov 0x11eab0,%ax <== NOT EXECUTED 10bf36: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10bf3c: 66 a3 b0 ea 11 00 mov %ax,0x11eab0 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10bf42: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10bf48: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10bf4b: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10bf4d: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10bf50: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10bf53: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10bf55: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10bf58: 53 push %ebx <== NOT EXECUTED 10bf59: 9d popf <== NOT EXECUTED 10bf5a: 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 ) { 10bf5b: 8b 51 14 mov 0x14(%ecx),%edx <== NOT EXECUTED 10bf5e: a1 88 ea 11 00 mov 0x11ea88,%eax <== NOT EXECUTED 10bf63: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10bf66: 73 1c jae 10bf84 <_Thread_Clear_state+0x84> <== NOT EXECUTED _Thread_Heir = the_thread; 10bf68: 89 0d 88 ea 11 00 mov %ecx,0x11ea88 <== NOT EXECUTED if ( _Thread_Executing->is_preemptible || 10bf6e: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED 10bf73: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10bf77: 75 04 jne 10bf7d <_Thread_Clear_state+0x7d> <== NOT EXECUTED 10bf79: 85 d2 test %edx,%edx <== NOT EXECUTED 10bf7b: 75 07 jne 10bf84 <_Thread_Clear_state+0x84> <== NOT EXECUTED the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 10bf7d: c6 05 cc ea 11 00 01 movb $0x1,0x11eacc <== NOT EXECUTED } } } _ISR_Enable( level ); 10bf84: 53 push %ebx <== NOT EXECUTED 10bf85: 9d popf <== NOT EXECUTED } 10bf86: 5b pop %ebx <== NOT EXECUTED 10bf87: c9 leave <== NOT EXECUTED 10bf88: c3 ret <== NOT EXECUTED 0010bf8c <_Thread_Close>: void _Thread_Close( Objects_Information *information, Thread_Control *the_thread ) { 10bf8c: 55 push %ebp <== NOT EXECUTED 10bf8d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bf8f: 56 push %esi <== NOT EXECUTED 10bf90: 53 push %ebx <== NOT EXECUTED 10bf91: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bf94: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10bf97: 0f b7 56 08 movzwl 0x8(%esi),%edx <== NOT EXECUTED 10bf9b: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10bf9e: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) <== NOT EXECUTED 10bfa5: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10bfaa: 48 dec %eax <== NOT EXECUTED 10bfab: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED * disappear and set a transient state on it. So we temporarily * unnest dispatching. */ _Thread_Unnest_dispatch(); _User_extensions_Thread_delete( the_thread ); 10bfb0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bfb3: 56 push %esi <== NOT EXECUTED 10bfb4: e8 3f 11 00 00 call 10d0f8 <_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 10bfb9: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10bfbe: 40 inc %eax <== NOT EXECUTED 10bfbf: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== 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 ); 10bfc4: 59 pop %ecx <== NOT EXECUTED 10bfc5: 58 pop %eax <== NOT EXECUTED 10bfc6: 56 push %esi <== NOT EXECUTED 10bfc7: 53 push %ebx <== NOT EXECUTED 10bfc8: e8 23 f6 ff ff call 10b5f0 <_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 ); 10bfcd: 58 pop %eax <== NOT EXECUTED 10bfce: 5a pop %edx <== NOT EXECUTED 10bfcf: 6a 01 push $0x1 <== NOT EXECUTED 10bfd1: 56 push %esi <== NOT EXECUTED 10bfd2: e8 85 0b 00 00 call 10cb5c <_Thread_Set_state> <== NOT EXECUTED if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 10bfd7: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10bfda: e8 a5 09 00 00 call 10c984 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 10bfdf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bfe2: 84 c0 test %al,%al <== NOT EXECUTED 10bfe4: 75 06 jne 10bfec <_Thread_Close+0x60> <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 10bfe6: 83 7e 50 02 cmpl $0x2,0x50(%esi) <== NOT EXECUTED 10bfea: 74 68 je 10c054 <_Thread_Close+0xc8> <== 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 ) ) 10bfec: 3b 35 80 ea 11 00 cmp 0x11ea80,%esi <== NOT EXECUTED 10bff2: 74 74 je 10c068 <_Thread_Close+0xdc> <== NOT EXECUTED _Thread_Deallocate_fp(); #endif the_thread->fp_context = NULL; 10bff4: c7 86 ec 00 00 00 00 movl $0x0,0xec(%esi) <== NOT EXECUTED 10bffb: 00 00 00 <== NOT EXECUTED if ( the_thread->Start.fp_context ) 10bffe: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED 10c004: 85 c0 test %eax,%eax <== NOT EXECUTED 10c006: 74 0c je 10c014 <_Thread_Close+0x88> <== NOT EXECUTED (void) _Workspace_Free( the_thread->Start.fp_context ); 10c008: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c00b: 50 push %eax <== NOT EXECUTED 10c00c: e8 b3 13 00 00 call 10d3c4 <_Workspace_Free> <== NOT EXECUTED 10c011: 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 ); 10c014: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c017: 56 push %esi <== NOT EXECUTED 10c018: e8 ef 0c 00 00 call 10cd0c <_Thread_Stack_Free> <== NOT EXECUTED the_thread->Start.stack = NULL; 10c01d: c7 86 d0 00 00 00 00 movl $0x0,0xd0(%esi) <== NOT EXECUTED 10c024: 00 00 00 <== NOT EXECUTED if ( the_thread->extensions ) 10c027: 8b 86 00 01 00 00 mov 0x100(%esi),%eax <== NOT EXECUTED 10c02d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c030: 85 c0 test %eax,%eax <== NOT EXECUTED 10c032: 74 0c je 10c040 <_Thread_Close+0xb4> <== NOT EXECUTED (void) _Workspace_Free( the_thread->extensions ); 10c034: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c037: 50 push %eax <== NOT EXECUTED 10c038: e8 87 13 00 00 call 10d3c4 <_Workspace_Free> <== NOT EXECUTED 10c03d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_thread->extensions = NULL; 10c040: c7 86 00 01 00 00 00 movl $0x0,0x100(%esi) <== NOT EXECUTED 10c047: 00 00 00 <== NOT EXECUTED } 10c04a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c04d: 5b pop %ebx <== NOT EXECUTED 10c04e: 5e pop %esi <== NOT EXECUTED 10c04f: c9 leave <== NOT EXECUTED 10c050: c3 ret <== NOT EXECUTED 10c051: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ _Thread_Set_state( the_thread, STATES_DORMANT ); if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { if ( _Watchdog_Is_active( &the_thread->Timer ) ) (void) _Watchdog_Remove( &the_thread->Timer ); 10c054: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c057: 8d 46 48 lea 0x48(%esi),%eax <== NOT EXECUTED 10c05a: 50 push %eax <== NOT EXECUTED 10c05b: e8 88 12 00 00 call 10d2e8 <_Watchdog_Remove> <== NOT EXECUTED 10c060: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c063: eb 87 jmp 10bfec <_Thread_Close+0x60> <== NOT EXECUTED 10c065: 8d 76 00 lea 0x0(%esi),%esi <== 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( 10c068: c7 05 80 ea 11 00 00 movl $0x0,0x11ea80 <== NOT EXECUTED 10c06f: 00 00 00 <== NOT EXECUTED 10c072: eb 80 jmp 10bff4 <_Thread_Close+0x68> <== NOT EXECUTED 0010c074 <_Thread_Create_idle>: * * _Thread_Create_idle */ void _Thread_Create_idle( void ) { 10c074: 55 push %ebp <== NOT EXECUTED 10c075: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c077: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10c07a: 68 80 eb 11 00 push $0x11eb80 <== NOT EXECUTED 10c07f: e8 ec f4 ff ff call 10b570 <_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(); 10c084: a3 cc eb 11 00 mov %eax,0x11ebcc <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10c089: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10c08e: 40 inc %eax <== NOT EXECUTED 10c08f: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED * that when _Thread_Initialize unnests dispatch that we do not * do anything stupid. */ _Thread_Disable_dispatch(); _Thread_Initialize( 10c094: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10c099: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED 10c09c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c09f: 68 d0 85 11 00 push $0x1185d0 <== NOT EXECUTED 10c0a4: 6a 00 push $0x0 <== NOT EXECUTED 10c0a6: 6a 00 push $0x0 <== NOT EXECUTED 10c0a8: 6a 00 push $0x0 <== NOT EXECUTED 10c0aa: 6a 01 push $0x1 <== NOT EXECUTED 10c0ac: 0f b6 05 b4 a4 11 00 movzbl 0x11a4b4,%eax <== NOT EXECUTED 10c0b3: 50 push %eax <== NOT EXECUTED 10c0b4: 6a 00 push $0x0 <== NOT EXECUTED 10c0b6: a1 b0 a4 11 00 mov 0x11a4b0,%eax <== NOT EXECUTED 10c0bb: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10c0bd: 73 02 jae 10c0c1 <_Thread_Create_idle+0x4d> <== NOT EXECUTED 10c0bf: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c0c1: 50 push %eax <== NOT EXECUTED 10c0c2: 6a 00 push $0x0 <== NOT EXECUTED 10c0c4: ff 35 cc eb 11 00 pushl 0x11ebcc <== NOT EXECUTED 10c0ca: 68 80 eb 11 00 push $0x11eb80 <== NOT EXECUTED 10c0cf: e8 78 02 00 00 call 10c34c <_Thread_Initialize> <== NOT EXECUTED 10c0d4: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10c0d9: 48 dec %eax <== NOT EXECUTED 10c0da: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 10c0df: 8b 15 cc eb 11 00 mov 0x11ebcc,%edx <== NOT EXECUTED 10c0e5: 89 15 bc ea 11 00 mov %edx,0x11eabc <== NOT EXECUTED 10c0eb: 89 15 88 ea 11 00 mov %edx,0x11ea88 <== NOT EXECUTED _Thread_Executing = _Thread_Idle; _Thread_Start( 10c0f1: 83 c4 24 add $0x24,%esp <== NOT EXECUTED 10c0f4: 6a 00 push $0x0 <== NOT EXECUTED 10c0f6: 6a 00 push $0x0 <== NOT EXECUTED 10c0f8: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10c0fd: ff 70 14 pushl 0x14(%eax) <== NOT EXECUTED 10c100: 6a 00 push $0x0 <== NOT EXECUTED 10c102: 52 push %edx <== NOT EXECUTED 10c103: e8 9c 0c 00 00 call 10cda4 <_Thread_Start> <== NOT EXECUTED 10c108: 83 c4 20 add $0x20,%esp <== NOT EXECUTED _Configuration_Table->idle_task, NULL, 0 ); } 10c10b: c9 leave <== NOT EXECUTED 10c10c: c3 ret <== NOT EXECUTED 0010c110 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 10c110: 55 push %ebp <== NOT EXECUTED 10c111: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c113: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10c116: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10c119: 50 push %eax <== NOT EXECUTED 10c11a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c11d: e8 aa 01 00 00 call 10c2cc <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10c122: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c125: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10c128: 85 d2 test %edx,%edx <== NOT EXECUTED 10c12a: 75 1c jne 10c148 <_Thread_Delay_ended+0x38> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10c12c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c12f: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10c134: 50 push %eax <== NOT EXECUTED 10c135: e8 c6 fd ff ff call 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 10c13a: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10c13f: 48 dec %eax <== NOT EXECUTED 10c140: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED 10c145: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_LOCAL: _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; } } 10c148: c9 leave <== NOT EXECUTED 10c149: c3 ret <== NOT EXECUTED 0010c14c <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10c14c: 55 push %ebp <== NOT EXECUTED 10c14d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c14f: 57 push %edi <== NOT EXECUTED 10c150: 56 push %esi <== NOT EXECUTED 10c151: 53 push %ebx <== NOT EXECUTED 10c152: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10c155: 8b 35 bc ea 11 00 mov 0x11eabc,%esi <== NOT EXECUTED _ISR_Disable( level ); 10c15b: 9c pushf <== NOT EXECUTED 10c15c: fa cli <== NOT EXECUTED 10c15d: 5a pop %edx <== NOT EXECUTED while ( _Context_Switch_necessary == TRUE ) { 10c15e: a0 cc ea 11 00 mov 0x11eacc,%al <== NOT EXECUTED 10c163: 84 c0 test %al,%al <== NOT EXECUTED 10c165: 0f 84 11 01 00 00 je 10c27c <_Thread_Dispatch+0x130> <== NOT EXECUTED 10c16b: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 10c16e: e9 d2 00 00 00 jmp 10c245 <_Thread_Dispatch+0xf9> <== NOT EXECUTED 10c173: 90 nop <== NOT EXECUTED 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 ) heir->cpu_time_budget = _Thread_Ticks_per_timeslice; _ISR_Enable( level ); 10c174: 52 push %edx <== NOT EXECUTED 10c175: 9d popf <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec uptime, ran; _TOD_Get_uptime( &uptime ); 10c176: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c179: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10c17c: 50 push %eax <== NOT EXECUTED 10c17d: e8 8a 30 00 00 call 10f20c <_TOD_Get_uptime> <== NOT EXECUTED _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); 10c182: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c185: 57 push %edi <== NOT EXECUTED 10c186: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10c189: 50 push %eax <== NOT EXECUTED 10c18a: 68 c4 ea 11 00 push $0x11eac4 <== NOT EXECUTED 10c18f: e8 7c 0d 00 00 call 10cf10 <_Timespec_Subtract> <== NOT EXECUTED _Timespec_Add_to( &executing->cpu_time_used, &ran ); 10c194: 58 pop %eax <== NOT EXECUTED 10c195: 5a pop %edx <== NOT EXECUTED 10c196: 57 push %edi <== NOT EXECUTED 10c197: 8d 86 84 00 00 00 lea 0x84(%esi),%eax <== NOT EXECUTED 10c19d: 50 push %eax <== NOT EXECUTED 10c19e: e8 35 0d 00 00 call 10ced8 <_Timespec_Add_to> <== NOT EXECUTED _Thread_Time_of_last_context_switch = uptime; 10c1a3: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10c1a6: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10c1a9: a3 c4 ea 11 00 mov %eax,0x11eac4 <== NOT EXECUTED 10c1ae: 89 15 c8 ea 11 00 mov %edx,0x11eac8 <== NOT EXECUTED #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10c1b4: 8b 15 84 ea 11 00 mov 0x11ea84,%edx <== NOT EXECUTED 10c1ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c1bd: 85 d2 test %edx,%edx <== NOT EXECUTED 10c1bf: 74 10 je 10c1d1 <_Thread_Dispatch+0x85> <== NOT EXECUTED executing->libc_reent = *_Thread_libc_reent; 10c1c1: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10c1c3: 89 86 f0 00 00 00 mov %eax,0xf0(%esi) <== NOT EXECUTED *_Thread_libc_reent = heir->libc_reent; 10c1c9: 8b 83 f0 00 00 00 mov 0xf0(%ebx),%eax <== NOT EXECUTED 10c1cf: 89 02 mov %eax,(%edx) <== NOT EXECUTED } _User_extensions_Thread_switch( executing, heir ); 10c1d1: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c1d4: 53 push %ebx <== NOT EXECUTED 10c1d5: 56 push %esi <== NOT EXECUTED 10c1d6: e8 9d 0f 00 00 call 10d178 <_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 ); 10c1db: 59 pop %ecx <== NOT EXECUTED 10c1dc: 58 pop %eax <== NOT EXECUTED 10c1dd: 8d 83 d4 00 00 00 lea 0xd4(%ebx),%eax <== NOT EXECUTED 10c1e3: 50 push %eax <== NOT EXECUTED 10c1e4: 8d 86 d4 00 00 00 lea 0xd4(%esi),%eax <== NOT EXECUTED 10c1ea: 50 push %eax <== NOT EXECUTED 10c1eb: e8 90 12 00 00 call 10d480 <_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) && 10c1f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c1f3: 8b 96 ec 00 00 00 mov 0xec(%esi),%edx <== NOT EXECUTED 10c1f9: 85 d2 test %edx,%edx <== NOT EXECUTED 10c1fb: 74 36 je 10c233 <_Thread_Dispatch+0xe7> <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10c1fd: a1 80 ea 11 00 mov 0x11ea80,%eax <== NOT EXECUTED 10c202: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10c204: 74 2d je 10c233 <_Thread_Dispatch+0xe7> <== NOT EXECUTED !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10c206: 85 c0 test %eax,%eax <== NOT EXECUTED 10c208: 74 11 je 10c21b <_Thread_Dispatch+0xcf> <== NOT EXECUTED _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10c20a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c20d: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10c212: 50 push %eax <== NOT EXECUTED 10c213: e8 9c 12 00 00 call 10d4b4 <_CPU_Context_save_fp> <== NOT EXECUTED 10c218: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Context_Restore_fp( &executing->fp_context ); 10c21b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c21e: 8d 86 ec 00 00 00 lea 0xec(%esi),%eax <== NOT EXECUTED 10c224: 50 push %eax <== NOT EXECUTED 10c225: e8 94 12 00 00 call 10d4be <_CPU_Context_restore_fp> <== NOT EXECUTED _Thread_Allocated_fp = executing; 10c22a: 89 35 80 ea 11 00 mov %esi,0x11ea80 <== NOT EXECUTED 10c230: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10c233: 8b 35 bc ea 11 00 mov 0x11eabc,%esi <== NOT EXECUTED _ISR_Disable( level ); 10c239: 9c pushf <== NOT EXECUTED 10c23a: fa cli <== NOT EXECUTED 10c23b: 5a pop %edx <== NOT EXECUTED Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Context_Switch_necessary == TRUE ) { 10c23c: a0 cc ea 11 00 mov 0x11eacc,%al <== NOT EXECUTED 10c241: 84 c0 test %al,%al <== NOT EXECUTED 10c243: 74 37 je 10c27c <_Thread_Dispatch+0x130> <== NOT EXECUTED heir = _Thread_Heir; 10c245: 8b 1d 88 ea 11 00 mov 0x11ea88,%ebx <== NOT EXECUTED _Thread_Dispatch_disable_level = 1; 10c24b: c7 05 f8 e9 11 00 01 movl $0x1,0x11e9f8 <== NOT EXECUTED 10c252: 00 00 00 <== NOT EXECUTED _Context_Switch_necessary = FALSE; 10c255: c6 05 cc ea 11 00 00 movb $0x0,0x11eacc <== NOT EXECUTED _Thread_Executing = heir; 10c25c: 89 1d bc ea 11 00 mov %ebx,0x11eabc <== 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 ) 10c262: 83 7b 7c 01 cmpl $0x1,0x7c(%ebx) <== NOT EXECUTED 10c266: 0f 85 08 ff ff ff jne 10c174 <_Thread_Dispatch+0x28> <== NOT EXECUTED heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c26c: a1 c4 e9 11 00 mov 0x11e9c4,%eax <== NOT EXECUTED 10c271: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10c274: e9 fb fe ff ff jmp 10c174 <_Thread_Dispatch+0x28> <== NOT EXECUTED 10c279: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED executing = _Thread_Executing; _ISR_Disable( level ); } _Thread_Dispatch_disable_level = 0; 10c27c: c7 05 f8 e9 11 00 00 movl $0x0,0x11e9f8 <== NOT EXECUTED 10c283: 00 00 00 <== NOT EXECUTED _ISR_Enable( level ); 10c286: 52 push %edx <== NOT EXECUTED 10c287: 9d popf <== NOT EXECUTED if ( _Thread_Do_post_task_switch_extension || 10c288: a1 a0 ea 11 00 mov 0x11eaa0,%eax <== NOT EXECUTED 10c28d: 85 c0 test %eax,%eax <== NOT EXECUTED 10c28f: 75 06 jne 10c297 <_Thread_Dispatch+0x14b> <== NOT EXECUTED 10c291: 80 7e 75 00 cmpb $0x0,0x75(%esi) <== NOT EXECUTED 10c295: 74 09 je 10c2a0 <_Thread_Dispatch+0x154> <== NOT EXECUTED executing->do_post_task_switch_extension ) { executing->do_post_task_switch_extension = false; 10c297: c6 46 75 00 movb $0x0,0x75(%esi) <== NOT EXECUTED _API_extensions_Run_postswitch(); 10c29b: e8 74 e9 ff ff call 10ac14 <_API_extensions_Run_postswitch> <== NOT EXECUTED } } 10c2a0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c2a3: 5b pop %ebx <== NOT EXECUTED 10c2a4: 5e pop %esi <== NOT EXECUTED 10c2a5: 5f pop %edi <== NOT EXECUTED 10c2a6: c9 leave <== NOT EXECUTED 10c2a7: c3 ret <== NOT EXECUTED 0010c2a8 <_Thread_Enable_dispatch>: */ #if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \ (__RTEMS_DO_NOT_INLINE_THREAD_ENABLE_DISPATCH__ == 1) ) void _Thread_Enable_dispatch( void ) { 10c2a8: 55 push %ebp <== NOT EXECUTED 10c2a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( --_Thread_Dispatch_disable_level ) 10c2ab: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10c2b0: 48 dec %eax <== NOT EXECUTED 10c2b1: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED 10c2b6: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10c2bb: 85 c0 test %eax,%eax <== NOT EXECUTED 10c2bd: 74 05 je 10c2c4 <_Thread_Enable_dispatch+0x1c> <== NOT EXECUTED return; _Thread_Dispatch(); } 10c2bf: c9 leave <== NOT EXECUTED 10c2c0: c3 ret <== NOT EXECUTED 10c2c1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10c2c4: 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(); 10c2c5: e9 82 fe ff ff jmp 10c14c <_Thread_Dispatch> <== NOT EXECUTED 0010ff80 <_Thread_Evaluate_mode>: * * XXX */ bool _Thread_Evaluate_mode( void ) { 10ff80: 55 push %ebp <== NOT EXECUTED 10ff81: 89 e5 mov %esp,%ebp <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 10ff83: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED if ( !_States_Is_ready( executing->current_state ) || 10ff88: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 10ff8b: 85 d2 test %edx,%edx <== NOT EXECUTED 10ff8d: 75 0e jne 10ff9d <_Thread_Evaluate_mode+0x1d> <== NOT EXECUTED 10ff8f: 3b 05 88 ea 11 00 cmp 0x11ea88,%eax <== NOT EXECUTED 10ff95: 74 11 je 10ffa8 <_Thread_Evaluate_mode+0x28> <== NOT EXECUTED 10ff97: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10ff9b: 74 0b je 10ffa8 <_Thread_Evaluate_mode+0x28> <== NOT EXECUTED ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) { _Context_Switch_necessary = TRUE; 10ff9d: c6 05 cc ea 11 00 01 movb $0x1,0x11eacc <== NOT EXECUTED 10ffa4: b0 01 mov $0x1,%al <== NOT EXECUTED return TRUE; } return FALSE; } 10ffa6: c9 leave <== NOT EXECUTED 10ffa7: c3 ret <== NOT EXECUTED executing = _Thread_Executing; if ( !_States_Is_ready( executing->current_state ) || ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) { _Context_Switch_necessary = TRUE; return TRUE; 10ffa8: 31 c0 xor %eax,%eax <== NOT EXECUTED } return FALSE; } 10ffaa: c9 leave <== NOT EXECUTED 10ffab: c3 ret <== NOT EXECUTED 0010c2cc <_Thread_Get>: Thread_Control *_Thread_Get ( Objects_Id id, Objects_Locations *location ) { 10c2cc: 55 push %ebp <== NOT EXECUTED 10c2cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c2cf: 53 push %ebx <== NOT EXECUTED 10c2d0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10c2d3: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c2d6: 8b 5d 0c mov 0xc(%ebp),%ebx <== 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 ) ) { 10c2d9: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10c2db: 74 4b je 10c328 <_Thread_Get+0x5c> <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10c2dd: 89 ca mov %ecx,%edx <== NOT EXECUTED 10c2df: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10c2e2: 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. 10c2e5: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10c2e8: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10c2eb: 77 2b ja 10c318 <_Thread_Get+0x4c> <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 10c2ed: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10c2ef: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED 10c2f2: 48 dec %eax <== NOT EXECUTED 10c2f3: 75 23 jne 10c318 <_Thread_Get+0x4c> <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } api_information = _Objects_Information_table[ the_api ]; 10c2f5: 8b 04 95 cc e9 11 00 mov 0x11e9cc(,%edx,4),%eax <== NOT EXECUTED if ( !api_information ) { 10c2fc: 85 c0 test %eax,%eax <== NOT EXECUTED 10c2fe: 74 44 je 10c344 <_Thread_Get+0x78> <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = api_information[ the_class ]; 10c300: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED if ( !information ) { 10c303: 85 c0 test %eax,%eax <== NOT EXECUTED 10c305: 74 3d je 10c344 <_Thread_Get+0x78> <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 10c307: 52 push %edx <== NOT EXECUTED 10c308: 53 push %ebx <== NOT EXECUTED 10c309: 51 push %ecx <== NOT EXECUTED 10c30a: 50 push %eax <== NOT EXECUTED 10c30b: e8 54 f7 ff ff call 10ba64 <_Objects_Get> <== NOT EXECUTED 10c310: 83 c4 10 add $0x10,%esp <== NOT EXECUTED done: return tp; } 10c313: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c316: c9 leave <== NOT EXECUTED 10c317: c3 ret <== NOT EXECUTED goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ *location = OBJECTS_ERROR; 10c318: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED 10c31e: 31 c0 xor %eax,%eax <== NOT EXECUTED tp = (Thread_Control *) _Objects_Get( information, id, location ); done: return tp; } 10c320: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c323: c9 leave <== NOT EXECUTED 10c324: c3 ret <== NOT EXECUTED 10c325: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10c328: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10c32d: 40 inc %eax <== NOT EXECUTED 10c32e: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; 10c333: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED tp = _Thread_Executing; 10c339: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED tp = (Thread_Control *) _Objects_Get( information, id, location ); done: return tp; } 10c33e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c341: c9 leave <== NOT EXECUTED 10c342: c3 ret <== NOT EXECUTED 10c343: 90 nop <== NOT EXECUTED goto done; } information = api_information[ the_class ]; if ( !information ) { *location = OBJECTS_ERROR; 10c344: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED 10c34a: eb d4 jmp 10c320 <_Thread_Get+0x54> <== NOT EXECUTED 0010ffac <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 10ffac: 55 push %ebp <== NOT EXECUTED 10ffad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ffaf: 53 push %ebx <== NOT EXECUTED 10ffb0: 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; 10ffb3: 8b 1d bc ea 11 00 mov 0x11eabc,%ebx <== NOT EXECUTED /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 10ffb9: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED _ISR_Set_level(level); 10ffbf: 85 c0 test %eax,%eax <== NOT EXECUTED 10ffc1: 0f 84 91 00 00 00 je 110058 <_Thread_Handler+0xac> <== NOT EXECUTED 10ffc7: fa cli <== NOT EXECUTED #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; 10ffc8: a0 b8 e7 11 00 mov 0x11e7b8,%al <== NOT EXECUTED 10ffcd: 88 45 fb mov %al,-0x5(%ebp) <== NOT EXECUTED doneConstructors = 1; 10ffd0: c6 05 b8 e7 11 00 01 movb $0x1,0x11e7b8 <== 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 ) ) { 10ffd7: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax <== NOT EXECUTED 10ffdd: 85 c0 test %eax,%eax <== NOT EXECUTED 10ffdf: 74 24 je 110005 <_Thread_Handler+0x59> <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10ffe1: a1 80 ea 11 00 mov 0x11ea80,%eax <== NOT EXECUTED 10ffe6: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10ffe8: 74 1b je 110005 <_Thread_Handler+0x59> <== NOT EXECUTED if ( _Thread_Allocated_fp != NULL ) 10ffea: 85 c0 test %eax,%eax <== NOT EXECUTED 10ffec: 74 11 je 10ffff <_Thread_Handler+0x53> <== NOT EXECUTED _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10ffee: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fff1: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10fff6: 50 push %eax <== NOT EXECUTED 10fff7: e8 b8 d4 ff ff call 10d4b4 <_CPU_Context_save_fp> <== NOT EXECUTED 10fffc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Allocated_fp = executing; 10ffff: 89 1d 80 ea 11 00 mov %ebx,0x11ea80 <== 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 ); 110005: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110008: 53 push %ebx <== NOT EXECUTED 110009: e8 e2 cf ff ff call 10cff0 <_User_extensions_Thread_begin> <== NOT EXECUTED /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 11000e: e8 95 c2 ff ff call 10c2a8 <_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) */ 110013: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110016: 80 7d fb 00 cmpb $0x0,-0x5(%ebp) <== NOT EXECUTED 11001a: 74 6c je 110088 <_Thread_Handler+0xdc> <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 11001c: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax <== NOT EXECUTED 110022: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 110025: 74 71 je 110098 <_Thread_Handler+0xec> <== NOT EXECUTED 110027: 73 37 jae 110060 <_Thread_Handler+0xb4> <== NOT EXECUTED case THREAD_START_NUMERIC: executing->Wait.return_argument = 110029: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11002c: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 110032: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 110038: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 11003b: 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 ); 11003e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110041: 53 push %ebx <== NOT EXECUTED 110042: e8 e5 cf ff ff call 10d02c <_User_extensions_Thread_exitted> <== NOT EXECUTED _Internal_error_Occurred( 110047: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 11004a: 6a 06 push $0x6 <== NOT EXECUTED 11004c: 6a 01 push $0x1 <== NOT EXECUTED 11004e: 6a 00 push $0x0 <== NOT EXECUTED 110050: e8 87 b4 ff ff call 10b4dc <_Internal_error_Occurred> <== NOT EXECUTED 110055: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; _ISR_Set_level(level); 110058: fb sti <== NOT EXECUTED 110059: e9 6a ff ff ff jmp 10ffc8 <_Thread_Handler+0x1c> <== NOT EXECUTED 11005e: 66 90 xchg %ax,%ax <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 110060: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 110063: 74 4b je 1100b0 <_Thread_Handler+0x104> <== NOT EXECUTED 110065: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 110068: 75 d4 jne 11003e <_Thread_Handler+0x92> <== NOT EXECUTED executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 11006a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11006d: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 110073: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 110079: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 11007f: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 110082: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110085: eb b7 jmp 11003e <_Thread_Handler+0x92> <== NOT EXECUTED 110087: 90 nop <== NOT EXECUTED * 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) */ { _init (); 110088: e8 d3 6d 00 00 call 116e60 <__start_set_sysctl_set> <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 11008d: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax <== NOT EXECUTED 110093: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 110096: 75 8f jne 110027 <_Thread_Handler+0x7b> <== NOT EXECUTED (*(Thread_Entry_numeric) executing->Start.entry_point)( executing->Start.numeric_argument ); break; case THREAD_START_POINTER: executing->Wait.return_argument = 110098: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11009b: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 1100a1: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 1100a7: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 1100aa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1100ad: eb 8f jmp 11003e <_Thread_Handler+0x92> <== NOT EXECUTED 1100af: 90 nop <== NOT EXECUTED (*(Thread_Entry_pointer) executing->Start.entry_point)( executing->Start.pointer_argument ); break; case THREAD_START_BOTH_POINTER_FIRST: executing->Wait.return_argument = 1100b0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1100b3: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 1100b9: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 1100bf: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 1100c5: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 1100c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1100cb: e9 6e ff ff ff jmp 11003e <_Thread_Handler+0x92> <== NOT EXECUTED 0010c554 <_Thread_Handler_initialization>: #if defined(RTEMS_MULTIPROCESSING) , uint32_t maximum_proxies #endif ) { 10c554: 55 push %ebp <== NOT EXECUTED 10c555: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c557: 53 push %ebx <== NOT EXECUTED 10c558: 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) 10c55b: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10c560: 8b 58 20 mov 0x20(%eax),%ebx <== NOT EXECUTED 10c563: 85 db test %ebx,%ebx <== NOT EXECUTED 10c565: 0f 94 c2 sete %dl <== NOT EXECUTED 10c568: 8b 48 24 mov 0x24(%eax),%ecx <== NOT EXECUTED 10c56b: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10c56d: 0f 94 c0 sete %al <== NOT EXECUTED 10c570: 38 c2 cmp %al,%dl <== NOT EXECUTED 10c572: 0f 85 a5 00 00 00 jne 10c61d <_Thread_Handler_initialization+0xc9> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 10c578: c6 05 cc ea 11 00 00 movb $0x0,0x11eacc <== NOT EXECUTED _Thread_Executing = NULL; 10c57f: c7 05 bc ea 11 00 00 movl $0x0,0x11eabc <== NOT EXECUTED 10c586: 00 00 00 <== NOT EXECUTED _Thread_Heir = NULL; 10c589: c7 05 88 ea 11 00 00 movl $0x0,0x11ea88 <== NOT EXECUTED 10c590: 00 00 00 <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; 10c593: c7 05 80 ea 11 00 00 movl $0x0,0x11ea80 <== NOT EXECUTED 10c59a: 00 00 00 <== NOT EXECUTED #endif _Thread_Do_post_task_switch_extension = 0; 10c59d: c7 05 a0 ea 11 00 00 movl $0x0,0x11eaa0 <== NOT EXECUTED 10c5a4: 00 00 00 <== NOT EXECUTED _Thread_Maximum_extensions = maximum_extensions; 10c5a7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c5aa: a3 9c ea 11 00 mov %eax,0x11ea9c <== NOT EXECUTED _Thread_Ticks_per_timeslice = ticks_per_timeslice; 10c5af: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c5b2: a3 c4 e9 11 00 mov %eax,0x11e9c4 <== NOT EXECUTED _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error( 10c5b7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c5ba: 0f b6 05 b4 a4 11 00 movzbl 0x11a4b4,%eax <== NOT EXECUTED 10c5c1: 8d 44 40 03 lea 0x3(%eax,%eax,2),%eax <== NOT EXECUTED 10c5c5: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10c5c8: 50 push %eax <== NOT EXECUTED 10c5c9: e8 26 0e 00 00 call 10d3f4 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10c5ce: a3 c0 e9 11 00 mov %eax,0x11e9c0 <== NOT EXECUTED (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control) ); for ( index=0; index <= PRIORITY_MAXIMUM ; index++ ) 10c5d3: 0f b6 1d b4 a4 11 00 movzbl 0x11a4b4,%ebx <== NOT EXECUTED 10c5da: 89 c2 mov %eax,%edx <== NOT EXECUTED 10c5dc: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10c5de: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c5e1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10c5e4: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10c5e7: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10c5e9: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10c5f0: 89 52 08 mov %edx,0x8(%edx) <== NOT EXECUTED 10c5f3: 41 inc %ecx <== NOT EXECUTED 10c5f4: 83 c2 0c add $0xc,%edx <== NOT EXECUTED 10c5f7: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 10c5f9: 76 e9 jbe 10c5e4 <_Thread_Handler_initialization+0x90> <== NOT EXECUTED /* * Initialize this class of objects. */ _Objects_Initialize_information( 10c5fb: 50 push %eax <== NOT EXECUTED 10c5fc: 6a 08 push $0x8 <== NOT EXECUTED 10c5fe: 6a 01 push $0x1 <== NOT EXECUTED 10c600: 68 08 01 00 00 push $0x108 <== NOT EXECUTED 10c605: 6a 01 push $0x1 <== NOT EXECUTED 10c607: 6a 01 push $0x1 <== NOT EXECUTED 10c609: 6a 01 push $0x1 <== NOT EXECUTED 10c60b: 68 80 eb 11 00 push $0x11eb80 <== NOT EXECUTED 10c610: e8 b3 f4 ff ff call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10c615: 83 c4 20 add $0x20,%esp <== NOT EXECUTED FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10c618: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c61b: c9 leave <== NOT EXECUTED 10c61c: c3 ret <== NOT EXECUTED * BOTH stacks hooks must be set or both must be NULL. * Do not allow mixture. */ if ( !( (!_Configuration_Table->stack_allocate_hook) == (!_Configuration_Table->stack_free_hook) ) ) _Internal_error_Occurred( 10c61d: 52 push %edx <== NOT EXECUTED 10c61e: 6a 0f push $0xf <== NOT EXECUTED 10c620: 6a 01 push $0x1 <== NOT EXECUTED 10c622: 6a 00 push $0x0 <== NOT EXECUTED 10c624: e8 b3 ee ff ff call 10b4dc <_Internal_error_Occurred> <== NOT EXECUTED 0010c34c <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10c34c: 55 push %ebp <== NOT EXECUTED 10c34d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c34f: 57 push %edi <== NOT EXECUTED 10c350: 56 push %esi <== NOT EXECUTED 10c351: 53 push %ebx <== NOT EXECUTED 10c352: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c355: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10c358: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10c35b: 8a 45 18 mov 0x18(%ebp),%al <== NOT EXECUTED 10c35e: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED 10c361: 8a 4d 20 mov 0x20(%ebp),%cl <== NOT EXECUTED 10c364: 88 4d f2 mov %cl,-0xe(%ebp) <== NOT EXECUTED /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 10c367: 85 d2 test %edx,%edx <== NOT EXECUTED 10c369: 0f 84 b2 01 00 00 je 10c521 <_Thread_Initialize+0x1d5> <== NOT EXECUTED stack = the_thread->Start.stack; the_thread->Start.core_allocated_stack = TRUE; } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = FALSE; 10c36f: c6 83 c0 00 00 00 00 movb $0x0,0xc0(%ebx) <== NOT EXECUTED 10c376: 8b 45 14 mov 0x14(%ebp),%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 10c379: 89 93 c8 00 00 00 mov %edx,0xc8(%ebx) <== NOT EXECUTED * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 10c37f: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx) <== NOT EXECUTED /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 10c385: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10c389: 0f 85 2d 01 00 00 jne 10c4bc <_Thread_Initialize+0x170> <== NOT EXECUTED fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); if ( !fp_area ) { _Thread_Stack_Free( the_thread ); return FALSE; 10c38f: 31 ff xor %edi,%edi <== NOT EXECUTED 10c391: 31 c0 xor %eax,%eax <== NOT EXECUTED fp_area = _Context_Fp_start( fp_area, 0 ); } else fp_area = NULL; the_thread->fp_context = fp_area; 10c393: 89 83 ec 00 00 00 mov %eax,0xec(%ebx) <== NOT EXECUTED the_thread->Start.fp_context = fp_area; 10c399: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx) <== NOT EXECUTED * 10c39f: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10c3a6: 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 10c3ad: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) <== NOT EXECUTED * the heap 10c3b4: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED /* * Clear the libc reent hook. */ the_thread->libc_reent = NULL; 10c3bb: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx) <== NOT EXECUTED 10c3c2: 00 00 00 <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c3c5: a1 9c ea 11 00 mov 0x11ea9c,%eax <== NOT EXECUTED 10c3ca: 85 c0 test %eax,%eax <== NOT EXECUTED 10c3cc: 0f 85 06 01 00 00 jne 10c4d8 <_Thread_Initialize+0x18c> <== NOT EXECUTED return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 10c3d2: c7 83 00 01 00 00 00 movl $0x0,0x100(%ebx) <== NOT EXECUTED 10c3d9: 00 00 00 <== NOT EXECUTED 10c3dc: 31 f6 xor %esi,%esi <== NOT EXECUTED /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10c3de: 8a 45 f2 mov -0xe(%ebp),%al <== NOT EXECUTED 10c3e1: 88 83 ac 00 00 00 mov %al,0xac(%ebx) <== NOT EXECUTED the_thread->Start.budget_algorithm = budget_algorithm; 10c3e7: 8b 4d 24 mov 0x24(%ebp),%ecx <== NOT EXECUTED 10c3ea: 89 8b b0 00 00 00 mov %ecx,0xb0(%ebx) <== NOT EXECUTED the_thread->Start.budget_callout = budget_callout; 10c3f0: 8b 45 28 mov 0x28(%ebp),%eax <== NOT EXECUTED 10c3f3: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx) <== NOT EXECUTED switch ( budget_algorithm ) { 10c3f9: 83 f9 02 cmp $0x2,%ecx <== NOT EXECUTED 10c3fc: 75 08 jne 10c406 <_Thread_Initialize+0xba> <== 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; 10c3fe: a1 c4 e9 11 00 mov 0x11e9c4,%eax <== NOT EXECUTED 10c403: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 10c406: 8b 4d 2c mov 0x2c(%ebp),%ecx <== NOT EXECUTED 10c409: 89 8b b8 00 00 00 mov %ecx,0xb8(%ebx) <== NOT EXECUTED the_thread->current_state = STATES_DORMANT; 10c40f: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) <== NOT EXECUTED the_thread->Wait.queue = NULL; 10c416: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED the_thread->resource_count = 0; 10c41d: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) <== NOT EXECUTED the_thread->suspend_count = 0; 10c424: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED the_thread->real_priority = priority; 10c42b: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 10c42e: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED the_thread->Start.initial_priority = priority; 10c431: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) <== NOT EXECUTED _Thread_Set_priority( the_thread, priority ); 10c437: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c43a: 50 push %eax <== NOT EXECUTED 10c43b: 53 push %ebx <== NOT EXECUTED 10c43c: e8 af 06 00 00 call 10caf0 <_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; 10c441: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) <== NOT EXECUTED 10c448: 00 00 00 <== NOT EXECUTED the_thread->cpu_time_used.tv_nsec = 0; 10c44b: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) <== NOT EXECUTED 10c452: 00 00 00 <== NOT EXECUTED 10c455: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 10c459: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c45c: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 10c45f: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10c462: 8b 45 30 mov 0x30(%ebp),%eax <== NOT EXECUTED 10c465: 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 ); 10c468: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10c46b: e8 40 0c 00 00 call 10d0b0 <_User_extensions_Thread_create> <== NOT EXECUTED if ( !extension_status ) { 10c470: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c473: 84 c0 test %al,%al <== NOT EXECUTED 10c475: 75 39 jne 10c4b0 <_Thread_Initialize+0x164> <== NOT EXECUTED if ( extensions_area ) 10c477: 85 f6 test %esi,%esi <== NOT EXECUTED 10c479: 74 0c je 10c487 <_Thread_Initialize+0x13b> <== NOT EXECUTED (void) _Workspace_Free( extensions_area ); 10c47b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c47e: 56 push %esi <== NOT EXECUTED 10c47f: e8 40 0f 00 00 call 10d3c4 <_Workspace_Free> <== NOT EXECUTED 10c484: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 10c487: 85 ff test %edi,%edi <== NOT EXECUTED 10c489: 74 0c je 10c497 <_Thread_Initialize+0x14b> <== NOT EXECUTED (void) _Workspace_Free( fp_area ); 10c48b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c48e: 57 push %edi <== NOT EXECUTED 10c48f: e8 30 0f 00 00 call 10d3c4 <_Workspace_Free> <== NOT EXECUTED 10c494: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif _Thread_Stack_Free( the_thread ); 10c497: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c49a: 53 push %ebx <== NOT EXECUTED 10c49b: e8 6c 08 00 00 call 10cd0c <_Thread_Stack_Free> <== NOT EXECUTED 10c4a0: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c4a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return FALSE; } return TRUE; } 10c4a5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c4a8: 5b pop %ebx <== NOT EXECUTED 10c4a9: 5e pop %esi <== NOT EXECUTED 10c4aa: 5f pop %edi <== NOT EXECUTED 10c4ab: c9 leave <== NOT EXECUTED 10c4ac: c3 ret <== NOT EXECUTED 10c4ad: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * Mutex provides sufficient protection to let the user extensions * run safely. */ extension_status = _User_extensions_Thread_create( the_thread ); if ( !extension_status ) { 10c4b0: b0 01 mov $0x1,%al <== NOT EXECUTED return FALSE; } return TRUE; } 10c4b2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c4b5: 5b pop %ebx <== NOT EXECUTED 10c4b6: 5e pop %esi <== NOT EXECUTED 10c4b7: 5f pop %edi <== NOT EXECUTED 10c4b8: c9 leave <== NOT EXECUTED 10c4b9: c3 ret <== NOT EXECUTED 10c4ba: 66 90 xchg %ax,%ax <== NOT EXECUTED */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10c4bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c4bf: 6a 6c push $0x6c <== NOT EXECUTED 10c4c1: e8 16 0f 00 00 call 10d3dc <_Workspace_Allocate> <== NOT EXECUTED 10c4c6: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( !fp_area ) { 10c4c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c4cb: 85 c0 test %eax,%eax <== NOT EXECUTED 10c4cd: 0f 85 c0 fe ff ff jne 10c393 <_Thread_Initialize+0x47> <== NOT EXECUTED 10c4d3: eb c2 jmp 10c497 <_Thread_Initialize+0x14b> <== NOT EXECUTED 10c4d5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { extensions_area = _Workspace_Allocate( 10c4d8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c4db: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax <== NOT EXECUTED 10c4e2: 50 push %eax <== NOT EXECUTED 10c4e3: e8 f4 0e 00 00 call 10d3dc <_Workspace_Allocate> <== NOT EXECUTED 10c4e8: 89 c6 mov %eax,%esi <== NOT EXECUTED (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 10c4ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c4ed: 85 c0 test %eax,%eax <== NOT EXECUTED 10c4ef: 74 96 je 10c487 <_Thread_Initialize+0x13b> <== NOT EXECUTED return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 10c4f1: 89 83 00 01 00 00 mov %eax,0x100(%ebx) <== NOT EXECUTED * call. */ if ( the_thread->extensions ) { uint32_t i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 10c4f7: 83 3d 9c ea 11 00 ff cmpl $0xffffffff,0x11ea9c <== NOT EXECUTED 10c4fe: 0f 84 da fe ff ff je 10c3de <_Thread_Initialize+0x92> <== NOT EXECUTED 10c504: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c506: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10c508: a1 9c ea 11 00 mov 0x11ea9c,%eax <== NOT EXECUTED 10c50d: 40 inc %eax <== NOT EXECUTED 10c50e: 66 90 xchg %ax,%ax <== NOT EXECUTED the_thread->extensions[i] = NULL; 10c510: c7 04 91 00 00 00 00 movl $0x0,(%ecx,%edx,4) <== NOT EXECUTED * call. */ if ( the_thread->extensions ) { uint32_t i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 10c517: 42 inc %edx <== NOT EXECUTED 10c518: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10c51a: 77 f4 ja 10c510 <_Thread_Initialize+0x1c4> <== NOT EXECUTED 10c51c: e9 bd fe ff ff jmp 10c3de <_Thread_Initialize+0x92> <== NOT EXECUTED */ if ( !stack_area ) { actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10c521: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c524: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10c527: 53 push %ebx <== NOT EXECUTED 10c528: e8 7b 07 00 00 call 10cca8 <_Thread_Stack_Allocate> <== NOT EXECUTED if ( !actual_stack_size || actual_stack_size < stack_size ) 10c52d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c530: 85 c0 test %eax,%eax <== NOT EXECUTED 10c532: 74 17 je 10c54b <_Thread_Initialize+0x1ff> <== NOT EXECUTED 10c534: 39 45 14 cmp %eax,0x14(%ebp) <== NOT EXECUTED 10c537: 77 12 ja 10c54b <_Thread_Initialize+0x1ff> <== NOT EXECUTED return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 10c539: 8b 93 d0 00 00 00 mov 0xd0(%ebx),%edx <== NOT EXECUTED the_thread->Start.core_allocated_stack = TRUE; 10c53f: c6 83 c0 00 00 00 01 movb $0x1,0xc0(%ebx) <== NOT EXECUTED 10c546: e9 2e fe ff ff jmp 10c379 <_Thread_Initialize+0x2d> <== NOT EXECUTED (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); return FALSE; 10c54b: 31 c0 xor %eax,%eax 10c54d: e9 53 ff ff ff jmp 10c4a5 <_Thread_Initialize+0x159> <== NOT EXECUTED 0010f49c <_Thread_Load_environment>: */ void _Thread_Load_environment( Thread_Control *the_thread ) { 10f49c: 55 push %ebp <== NOT EXECUTED 10f49d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f49f: 57 push %edi <== NOT EXECUTED 10f4a0: 56 push %esi <== NOT EXECUTED 10f4a1: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10f4a4: 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 ) { 10f4a7: 8b ba cc 00 00 00 mov 0xcc(%edx),%edi <== NOT EXECUTED 10f4ad: 85 ff test %edi,%edi <== NOT EXECUTED 10f4af: 74 12 je 10f4c3 <_Thread_Load_environment+0x27> <== NOT EXECUTED the_thread->fp_context = the_thread->Start.fp_context; 10f4b1: 89 ba ec 00 00 00 mov %edi,0xec(%edx) <== NOT EXECUTED _Context_Initialize_fp( &the_thread->fp_context ); 10f4b7: be e0 eb 11 00 mov $0x11ebe0,%esi <== NOT EXECUTED 10f4bc: b9 1b 00 00 00 mov $0x1b,%ecx <== NOT EXECUTED 10f4c1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED } else #endif is_fp = false; the_thread->do_post_task_switch_extension = false; 10f4c3: c6 42 75 00 movb $0x0,0x75(%edx) <== NOT EXECUTED the_thread->is_preemptible = the_thread->Start.is_preemptible; 10f4c7: 8a 82 ac 00 00 00 mov 0xac(%edx),%al <== NOT EXECUTED 10f4cd: 88 42 76 mov %al,0x76(%edx) <== NOT EXECUTED the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 10f4d0: 8b 82 b0 00 00 00 mov 0xb0(%edx),%eax <== NOT EXECUTED 10f4d6: 89 42 7c mov %eax,0x7c(%edx) <== NOT EXECUTED the_thread->budget_callout = the_thread->Start.budget_callout; 10f4d9: 8b 82 b4 00 00 00 mov 0xb4(%edx),%eax <== NOT EXECUTED 10f4df: 89 82 80 00 00 00 mov %eax,0x80(%edx) <== NOT EXECUTED _Context_Initialize( 10f4e5: 83 ba b8 00 00 00 01 cmpl $0x1,0xb8(%edx) <== NOT EXECUTED 10f4ec: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10f4ee: 25 00 02 00 00 and $0x200,%eax <== NOT EXECUTED 10f4f3: 05 02 30 00 00 add $0x3002,%eax <== NOT EXECUTED 10f4f8: 89 82 d4 00 00 00 mov %eax,0xd4(%edx) <== NOT EXECUTED 10f4fe: 8b 82 c4 00 00 00 mov 0xc4(%edx),%eax <== NOT EXECUTED 10f504: 83 e8 04 sub $0x4,%eax <== NOT EXECUTED 10f507: 03 82 c8 00 00 00 add 0xc8(%edx),%eax <== NOT EXECUTED 10f50d: c7 00 ac ff 10 00 movl $0x10ffac,(%eax) <== NOT EXECUTED 10f513: 89 82 dc 00 00 00 mov %eax,0xdc(%edx) <== NOT EXECUTED 10f519: 89 82 d8 00 00 00 mov %eax,0xd8(%edx) <== NOT EXECUTED the_thread->Start.isr_level, _Thread_Handler, is_fp ); } 10f51f: 58 pop %eax <== NOT EXECUTED 10f520: 5e pop %esi <== NOT EXECUTED 10f521: 5f pop %edi <== NOT EXECUTED 10f522: c9 leave <== NOT EXECUTED 10f523: c3 ret <== NOT EXECUTED 0010f720 <_Thread_Ready>: */ void _Thread_Ready( Thread_Control *the_thread ) { 10f720: 55 push %ebp <== NOT EXECUTED 10f721: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f723: 53 push %ebx <== NOT EXECUTED 10f724: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Thread_Control *heir; _ISR_Disable( level ); 10f727: 9c pushf <== NOT EXECUTED 10f728: fa cli <== NOT EXECUTED 10f729: 5b pop %ebx <== NOT EXECUTED the_thread->current_state = STATES_READY; 10f72a: 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 10f731: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10f737: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10f73e: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10f741: 66 a1 b0 ea 11 00 mov 0x11eab0,%ax <== NOT EXECUTED 10f747: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10f74d: 66 a3 b0 ea 11 00 mov %ax,0x11eab0 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node ); 10f753: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10f759: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10f75c: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10f75e: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10f761: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10f764: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10f766: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10f769: 53 push %ebx <== NOT EXECUTED 10f76a: 9d popf <== NOT EXECUTED 10f76b: fa cli <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10f76c: 66 8b 0d b0 ea 11 00 mov 0x11eab0,%cx <== NOT EXECUTED 10f773: 31 d2 xor %edx,%edx <== NOT EXECUTED 10f775: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f777: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10f77b: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10f77e: 66 8b 8c 00 40 eb 11 mov 0x11eb40(%eax,%eax,1),%cx <== NOT EXECUTED 10f785: 00 <== NOT EXECUTED 10f786: 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. 10f78a: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10f78d: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10f790: 01 d0 add %edx,%eax <== NOT EXECUTED 10f792: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10f795: 8b 15 c0 e9 11 00 mov 0x11e9c0,%edx <== NOT EXECUTED 10f79b: 8b 04 82 mov (%edx,%eax,4),%eax <== NOT EXECUTED 10f79e: a3 88 ea 11 00 mov %eax,0x11ea88 <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10f7a3: 8b 15 bc ea 11 00 mov 0x11eabc,%edx <== NOT EXECUTED _Thread_Calculate_heir(); heir = _Thread_Heir; if ( !_Thread_Is_executing( heir ) && _Thread_Executing->is_preemptible ) 10f7a9: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10f7ab: 74 0d je 10f7ba <_Thread_Ready+0x9a> <== NOT EXECUTED 10f7ad: 80 7a 76 00 cmpb $0x0,0x76(%edx) <== NOT EXECUTED 10f7b1: 74 07 je 10f7ba <_Thread_Ready+0x9a> <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10f7b3: c6 05 cc ea 11 00 01 movb $0x1,0x11eacc <== NOT EXECUTED _ISR_Enable( level ); 10f7ba: 53 push %ebx <== NOT EXECUTED 10f7bb: 9d popf <== NOT EXECUTED } 10f7bc: 5b pop %ebx <== NOT EXECUTED 10f7bd: c9 leave <== NOT EXECUTED 10f7be: c3 ret <== NOT EXECUTED 00110368 <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 110368: 55 push %ebp <== NOT EXECUTED 110369: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11036b: 53 push %ebx <== NOT EXECUTED 11036c: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 11036f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED the_thread->resource_count = 0; 110372: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) <== NOT EXECUTED the_thread->suspend_count = 0; 110379: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED the_thread->is_preemptible = the_thread->Start.is_preemptible; 110380: 8a 83 ac 00 00 00 mov 0xac(%ebx),%al <== NOT EXECUTED 110386: 88 43 76 mov %al,0x76(%ebx) <== NOT EXECUTED the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 110389: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 11038f: 89 43 7c mov %eax,0x7c(%ebx) <== NOT EXECUTED the_thread->budget_callout = the_thread->Start.budget_callout; 110392: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax <== NOT EXECUTED 110398: 89 83 80 00 00 00 mov %eax,0x80(%ebx) <== NOT EXECUTED the_thread->Start.pointer_argument = pointer_argument; 11039e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1103a1: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) <== NOT EXECUTED the_thread->Start.numeric_argument = numeric_argument; 1103a7: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1103aa: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) <== NOT EXECUTED if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 1103b0: 53 push %ebx <== NOT EXECUTED 1103b1: e8 06 d0 ff ff call 10d3bc <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 1103b6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1103b9: 84 c0 test %al,%al <== NOT EXECUTED 1103bb: 75 06 jne 1103c3 <_Thread_Reset+0x5b> <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 1103bd: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 1103c1: 74 25 je 1103e8 <_Thread_Reset+0x80> <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 1103c3: 8b 83 bc 00 00 00 mov 0xbc(%ebx),%eax <== NOT EXECUTED 1103c9: 39 43 14 cmp %eax,0x14(%ebx) <== NOT EXECUTED 1103cc: 74 12 je 1103e0 <_Thread_Reset+0x78> <== NOT EXECUTED the_thread->real_priority = the_thread->Start.initial_priority; 1103ce: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 1103d1: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 1103d4: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 1103d7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1103da: 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 ); 1103db: e9 dc d1 ff ff jmp 10d5bc <_Thread_Set_priority> <== NOT EXECUTED } } 1103e0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1103e3: c9 leave <== NOT EXECUTED 1103e4: c3 ret <== NOT EXECUTED 1103e5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_thread->Start.numeric_argument = numeric_argument; if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { if ( _Watchdog_Is_active( &the_thread->Timer ) ) (void) _Watchdog_Remove( &the_thread->Timer ); 1103e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1103eb: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 1103ee: 50 push %eax <== NOT EXECUTED 1103ef: e8 00 da ff ff call 10ddf4 <_Watchdog_Remove> <== NOT EXECUTED 1103f4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1103f7: eb ca jmp 1103c3 <_Thread_Reset+0x5b> <== NOT EXECUTED 0010f7c0 <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 10f7c0: 55 push %ebp <== NOT EXECUTED 10f7c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f7c3: 56 push %esi <== NOT EXECUTED 10f7c4: 53 push %ebx <== NOT EXECUTED ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10f7c5: 8b 0d bc ea 11 00 mov 0x11eabc,%ecx <== NOT EXECUTED ready = executing->ready; 10f7cb: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx <== NOT EXECUTED _ISR_Disable( level ); 10f7d1: 9c pushf <== NOT EXECUTED 10f7d2: fa cli <== NOT EXECUTED 10f7d3: 5e pop %esi <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10f7d4: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10f7d6: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10f7d9: 74 35 je 10f810 <_Thread_Reset_timeslice+0x50> <== NOT EXECUTED 10f7db: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10f7dd: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10f7e0: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10f7e3: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10f7e5: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 10f7e8: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10f7ea: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10f7ed: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED 10f7f0: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10f7f2: 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 ); 10f7f5: 56 push %esi <== NOT EXECUTED 10f7f6: 9d popf <== NOT EXECUTED 10f7f7: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( executing ) ) 10f7f8: 3b 0d 88 ea 11 00 cmp 0x11ea88,%ecx <== NOT EXECUTED 10f7fe: 74 18 je 10f818 <_Thread_Reset_timeslice+0x58> <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; 10f800: c6 05 cc ea 11 00 01 movb $0x1,0x11eacc <== NOT EXECUTED _ISR_Enable( level ); 10f807: 56 push %esi <== NOT EXECUTED 10f808: 9d popf <== NOT EXECUTED } 10f809: 5b pop %ebx <== NOT EXECUTED 10f80a: 5e pop %esi <== NOT EXECUTED 10f80b: c9 leave <== NOT EXECUTED 10f80c: c3 ret <== NOT EXECUTED 10f80d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED executing = _Thread_Executing; ready = executing->ready; _ISR_Disable( level ); if ( _Chain_Has_only_one_node( ready ) ) { _ISR_Enable( level ); 10f810: 56 push %esi <== NOT EXECUTED 10f811: 9d popf <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10f812: 5b pop %ebx <== NOT EXECUTED 10f813: 5e pop %esi <== NOT EXECUTED 10f814: c9 leave <== NOT EXECUTED 10f815: c3 ret <== NOT EXECUTED 10f816: 66 90 xchg %ax,%ax <== NOT EXECUTED _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) ready->first; 10f818: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10f81a: a3 88 ea 11 00 mov %eax,0x11ea88 <== NOT EXECUTED 10f81f: eb df jmp 10f800 <_Thread_Reset_timeslice+0x40> <== NOT EXECUTED 0010d528 <_Thread_Restart>: bool _Thread_Restart( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10d528: 55 push %ebp <== NOT EXECUTED 10d529: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d52b: 53 push %ebx <== NOT EXECUTED 10d52c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d52f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( !_States_Is_dormant( the_thread->current_state ) ) { 10d532: f6 43 10 01 testb $0x1,0x10(%ebx) <== NOT EXECUTED 10d536: 74 08 je 10d540 <_Thread_Restart+0x18> <== NOT EXECUTED 10d538: 31 c0 xor %eax,%eax <== NOT EXECUTED return TRUE; } return FALSE; } 10d53a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d53d: c9 leave <== NOT EXECUTED 10d53e: c3 ret <== NOT EXECUTED 10d53f: 90 nop <== NOT EXECUTED Thread_Entry_numeric_type numeric_argument ) { if ( !_States_Is_dormant( the_thread->current_state ) ) { _Thread_Set_transient( the_thread ); 10d540: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d543: 53 push %ebx <== NOT EXECUTED 10d544: e8 b7 01 00 00 call 10d700 <_Thread_Set_transient> <== NOT EXECUTED _Thread_Reset( the_thread, pointer_argument, numeric_argument ); 10d549: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10d54c: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10d54f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d552: 53 push %ebx <== NOT EXECUTED 10d553: e8 10 2e 00 00 call 110368 <_Thread_Reset> <== NOT EXECUTED _Thread_Load_environment( the_thread ); 10d558: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10d55b: e8 e4 2a 00 00 call 110044 <_Thread_Load_environment> <== NOT EXECUTED _Thread_Ready( the_thread ); 10d560: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10d563: e8 60 2d 00 00 call 1102c8 <_Thread_Ready> <== NOT EXECUTED _User_extensions_Thread_restart( the_thread ); 10d568: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10d56b: e8 94 06 00 00 call 10dc04 <_User_extensions_Thread_restart> <== NOT EXECUTED if ( _Thread_Is_executing ( the_thread ) ) 10d570: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d573: 3b 1d 7c 17 12 00 cmp 0x12177c,%ebx <== NOT EXECUTED 10d579: 74 09 je 10d584 <_Thread_Restart+0x5c> <== NOT EXECUTED 10d57b: b0 01 mov $0x1,%al <== NOT EXECUTED return TRUE; } return FALSE; } 10d57d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d580: c9 leave <== NOT EXECUTED 10d581: c3 ret <== NOT EXECUTED 10d582: 66 90 xchg %ax,%ax <== 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 10d584: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax <== NOT EXECUTED 10d58a: 85 c0 test %eax,%eax <== NOT EXECUTED 10d58c: 74 12 je 10d5a0 <_Thread_Restart+0x78> <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10d58e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d591: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax <== NOT EXECUTED 10d597: 50 push %eax <== NOT EXECUTED 10d598: e8 31 0a 00 00 call 10dfce <_CPU_Context_restore_fp> <== NOT EXECUTED 10d59d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, 10d5a0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d5a3: a1 7c 17 12 00 mov 0x12177c,%eax <== NOT EXECUTED 10d5a8: 05 d4 00 00 00 add $0xd4,%eax <== NOT EXECUTED 10d5ad: 50 push %eax <== NOT EXECUTED 10d5ae: e8 0a 0a 00 00 call 10dfbd <_CPU_Context_restore> <== NOT EXECUTED 10d5b3: b0 01 mov $0x1,%al <== NOT EXECUTED 10d5b5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d5b8: eb 80 jmp 10d53a <_Thread_Restart+0x12> <== NOT EXECUTED 0010dfe8 <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, bool force ) { 10dfe8: 55 push %ebp <== NOT EXECUTED 10dfe9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dfeb: 53 push %ebx <== NOT EXECUTED 10dfec: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10dfef: 8a 45 0c mov 0xc(%ebp),%al <== NOT EXECUTED ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10dff2: 9c pushf <== NOT EXECUTED 10dff3: fa cli <== NOT EXECUTED 10dff4: 5b pop %ebx <== NOT EXECUTED if ( force == TRUE ) 10dff5: 84 c0 test %al,%al <== NOT EXECUTED 10dff7: 74 13 je 10e00c <_Thread_Resume+0x24> <== NOT EXECUTED the_thread->suspend_count = 0; 10dff9: c7 41 70 00 00 00 00 movl $0x0,0x70(%ecx) <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { _ISR_Enable( level ); return; } current_state = the_thread->current_state; 10e000: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED if ( current_state & STATES_SUSPENDED ) { 10e003: a8 02 test $0x2,%al <== NOT EXECUTED 10e005: 75 15 jne 10e01c <_Thread_Resume+0x34> <== NOT EXECUTED _Context_Switch_necessary = TRUE; } } } _ISR_Enable( level ); 10e007: 53 push %ebx <== NOT EXECUTED 10e008: 9d popf <== NOT EXECUTED } 10e009: 5b pop %ebx <== NOT EXECUTED 10e00a: c9 leave <== NOT EXECUTED 10e00b: c3 ret <== NOT EXECUTED _ISR_Disable( level ); if ( force == TRUE ) the_thread->suspend_count = 0; else the_thread->suspend_count--; 10e00c: 8b 41 70 mov 0x70(%ecx),%eax <== NOT EXECUTED 10e00f: 48 dec %eax <== NOT EXECUTED 10e010: 89 41 70 mov %eax,0x70(%ecx) <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 10e013: 85 c0 test %eax,%eax <== NOT EXECUTED 10e015: 74 e9 je 10e000 <_Thread_Resume+0x18> <== NOT EXECUTED _ISR_Enable( level ); 10e017: 53 push %ebx <== NOT EXECUTED 10e018: 9d popf <== NOT EXECUTED } } } _ISR_Enable( level ); } 10e019: 5b pop %ebx <== NOT EXECUTED 10e01a: c9 leave <== NOT EXECUTED 10e01b: c3 ret <== 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( 10e01c: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED return; } current_state = the_thread->current_state; if ( current_state & STATES_SUSPENDED ) { current_state = 10e01f: 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 ) ) { 10e022: 85 c0 test %eax,%eax <== NOT EXECUTED 10e024: 75 e1 jne 10e007 <_Thread_Resume+0x1f> <== 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 10e026: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10e02c: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10e033: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10e036: 66 a1 10 a6 12 00 mov 0x12a610,%ax <== NOT EXECUTED 10e03c: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10e042: 66 a3 10 a6 12 00 mov %ax,0x12a610 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10e048: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10e04e: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10e051: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10e053: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10e056: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10e059: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10e05b: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10e05e: 53 push %ebx <== NOT EXECUTED 10e05f: 9d popf <== NOT EXECUTED 10e060: fa cli <== NOT EXECUTED if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 10e061: 8b 51 14 mov 0x14(%ecx),%edx <== NOT EXECUTED 10e064: a1 e8 a5 12 00 mov 0x12a5e8,%eax <== NOT EXECUTED 10e069: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10e06c: 73 99 jae 10e007 <_Thread_Resume+0x1f> <== NOT EXECUTED _Thread_Heir = the_thread; 10e06e: 89 0d e8 a5 12 00 mov %ecx,0x12a5e8 <== NOT EXECUTED if ( _Thread_Executing->is_preemptible || 10e074: a1 1c a6 12 00 mov 0x12a61c,%eax <== NOT EXECUTED 10e079: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10e07d: 74 0d je 10e08c <_Thread_Resume+0xa4> <== NOT EXECUTED the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 10e07f: c6 05 2c a6 12 00 01 movb $0x1,0x12a62c <== NOT EXECUTED 10e086: e9 7c ff ff ff jmp 10e007 <_Thread_Resume+0x1f> <== NOT EXECUTED 10e08b: 90 nop <== NOT EXECUTED _ISR_Flash( level ); if ( the_thread->current_priority < _Thread_Heir->current_priority ) { _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 10e08c: 85 d2 test %edx,%edx <== NOT EXECUTED 10e08e: 0f 85 73 ff ff ff jne 10e007 <_Thread_Resume+0x1f> <== NOT EXECUTED 10e094: eb e9 jmp 10e07f <_Thread_Resume+0x97> <== NOT EXECUTED 0010caf0 <_Thread_Set_priority>: void _Thread_Set_priority( Thread_Control *the_thread, Priority_Control new_priority ) { 10caf0: 55 push %ebp <== NOT EXECUTED 10caf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10caf3: 56 push %esi <== NOT EXECUTED 10caf4: 53 push %ebx <== NOT EXECUTED 10caf5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10caf8: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED the_thread->current_priority = new_priority; 10cafb: 89 53 14 mov %edx,0x14(%ebx) <== NOT EXECUTED the_thread->ready = &_Thread_Ready_chain[ new_priority ]; 10cafe: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10cb01: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10cb04: 03 05 c0 e9 11 00 add 0x11e9c0,%eax <== NOT EXECUTED 10cb0a: 89 83 8c 00 00 00 mov %eax,0x8c(%ebx) <== 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. */ 10cb10: 89 d1 mov %edx,%ecx <== NOT EXECUTED 10cb12: c1 e9 04 shr $0x4,%ecx <== NOT EXECUTED bool _Protected_heap_Walk( Heap_Control *the_heap, int source, 10cb15: 0f b7 c9 movzwl %cx,%ecx <== NOT EXECUTED 10cb18: 8d 84 09 40 eb 11 00 lea 0x11eb40(%ecx,%ecx,1),%eax <== NOT EXECUTED 10cb1f: 89 83 90 00 00 00 mov %eax,0x90(%ebx) <== NOT EXECUTED bool do_dump ); 10cb25: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10cb2a: 89 c6 mov %eax,%esi <== NOT EXECUTED 10cb2c: d3 e6 shl %cl,%esi <== NOT EXECUTED 10cb2e: 89 f1 mov %esi,%ecx <== NOT EXECUTED /** 10cb30: 66 89 b3 94 00 00 00 mov %si,0x94(%ebx) <== NOT EXECUTED * This routine walks the heap and tots up the free and allocated 10cb37: f7 d1 not %ecx <== NOT EXECUTED 10cb39: 66 89 8b 98 00 00 00 mov %cx,0x98(%ebx) <== NOT EXECUTED * sizes. * 10cb40: 83 e2 0f and $0xf,%edx <== NOT EXECUTED 10cb43: 88 d1 mov %dl,%cl <== NOT EXECUTED 10cb45: d3 e0 shl %cl,%eax <== NOT EXECUTED * @param[in] the_heap pointer to heap header 10cb47: 66 89 83 96 00 00 00 mov %ax,0x96(%ebx) <== NOT EXECUTED * @param[in] the_info pointer to a status information area 10cb4e: f7 d0 not %eax <== NOT EXECUTED 10cb50: 66 89 83 9a 00 00 00 mov %ax,0x9a(%ebx) <== NOT EXECUTED _Priority_Initialize_information( &the_thread->Priority_map, new_priority ); } 10cb57: 5b pop %ebx <== NOT EXECUTED 10cb58: 5e pop %esi <== NOT EXECUTED 10cb59: c9 leave <== NOT EXECUTED 10cb5a: c3 ret <== NOT EXECUTED 0010cb5c <_Thread_Set_state>: void _Thread_Set_state( Thread_Control *the_thread, States_Control state ) { 10cb5c: 55 push %ebp <== NOT EXECUTED 10cb5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cb5f: 56 push %esi <== NOT EXECUTED 10cb60: 53 push %ebx <== NOT EXECUTED 10cb61: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10cb64: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Chain_Control *ready; ready = the_thread->ready; 10cb67: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx <== NOT EXECUTED _ISR_Disable( level ); 10cb6d: 9c pushf <== NOT EXECUTED 10cb6e: fa cli <== NOT EXECUTED 10cb6f: 5e pop %esi <== NOT EXECUTED if ( !_States_Is_ready( the_thread->current_state ) ) { 10cb70: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10cb73: 85 c0 test %eax,%eax <== NOT EXECUTED 10cb75: 75 2d jne 10cba4 <_Thread_Set_state+0x48> <== NOT EXECUTED _States_Set( state, the_thread->current_state ); _ISR_Enable( level ); return; } the_thread->current_state = state; 10cb77: 89 4b 10 mov %ecx,0x10(%ebx) <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10cb7a: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10cb7c: 3b 42 08 cmp 0x8(%edx),%eax <== NOT EXECUTED 10cb7f: 74 2f je 10cbb0 <_Thread_Set_state+0x54> <== NOT EXECUTED 10cb81: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10cb83: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10cb86: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10cb89: 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 ); 10cb8b: 56 push %esi <== NOT EXECUTED 10cb8c: 9d popf <== NOT EXECUTED 10cb8d: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) 10cb8e: 3b 1d 88 ea 11 00 cmp 0x11ea88,%ebx <== NOT EXECUTED 10cb94: 74 62 je 10cbf8 <_Thread_Set_state+0x9c> <== NOT EXECUTED _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) 10cb96: 3b 1d bc ea 11 00 cmp 0x11eabc,%ebx <== NOT EXECUTED 10cb9c: 74 4e je 10cbec <_Thread_Set_state+0x90> <== NOT EXECUTED _Context_Switch_necessary = TRUE; _ISR_Enable( level ); 10cb9e: 56 push %esi <== NOT EXECUTED 10cb9f: 9d popf <== NOT EXECUTED } 10cba0: 5b pop %ebx <== NOT EXECUTED 10cba1: 5e pop %esi <== NOT EXECUTED 10cba2: c9 leave <== NOT EXECUTED 10cba3: c3 ret <== NOT EXECUTED Chain_Control *ready; ready = the_thread->ready; _ISR_Disable( level ); if ( !_States_Is_ready( the_thread->current_state ) ) { the_thread->current_state = 10cba4: 09 c1 or %eax,%ecx <== NOT EXECUTED 10cba6: 89 4b 10 mov %ecx,0x10(%ebx) <== NOT EXECUTED _States_Set( state, the_thread->current_state ); _ISR_Enable( level ); 10cba9: 56 push %esi <== NOT EXECUTED 10cbaa: 9d popf <== NOT EXECUTED if ( _Thread_Is_executing( the_thread ) ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10cbab: 5b pop %ebx <== NOT EXECUTED 10cbac: 5e pop %esi <== NOT EXECUTED 10cbad: c9 leave <== NOT EXECUTED 10cbae: c3 ret <== NOT EXECUTED 10cbaf: 90 nop <== NOT EXECUTED 10cbb0: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10cbb3: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10cbb5: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10cbbc: 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 10cbbf: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax <== NOT EXECUTED 10cbc5: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx <== NOT EXECUTED 10cbcc: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10cbcf: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10cbd3: 75 b6 jne 10cb8b <_Thread_Set_state+0x2f> <== NOT EXECUTED * to be resized 10cbd5: 66 a1 b0 ea 11 00 mov 0x11eab0,%ax <== NOT EXECUTED 10cbdb: 23 83 98 00 00 00 and 0x98(%ebx),%eax <== NOT EXECUTED 10cbe1: 66 a3 b0 ea 11 00 mov %ax,0x11eab0 <== NOT EXECUTED 10cbe7: eb a2 jmp 10cb8b <_Thread_Set_state+0x2f> <== NOT EXECUTED 10cbe9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) _Context_Switch_necessary = TRUE; 10cbec: c6 05 cc ea 11 00 01 movb $0x1,0x11eacc <== NOT EXECUTED 10cbf3: eb a9 jmp 10cb9e <_Thread_Set_state+0x42> <== NOT EXECUTED 10cbf5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10cbf8: 66 8b 0d b0 ea 11 00 mov 0x11eab0,%cx <== NOT EXECUTED 10cbff: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cc01: 89 d0 mov %edx,%eax <== NOT EXECUTED 10cc03: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10cc07: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10cc0a: 66 8b 8c 00 40 eb 11 mov 0x11eb40(%eax,%eax,1),%cx <== NOT EXECUTED 10cc11: 00 <== NOT EXECUTED 10cc12: 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. 10cc16: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10cc19: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10cc1c: 01 d0 add %edx,%eax <== NOT EXECUTED 10cc1e: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10cc21: 8b 15 c0 e9 11 00 mov 0x11e9c0,%edx <== NOT EXECUTED 10cc27: 8b 04 82 mov (%edx,%eax,4),%eax <== NOT EXECUTED 10cc2a: a3 88 ea 11 00 mov %eax,0x11ea88 <== NOT EXECUTED 10cc2f: e9 62 ff ff ff jmp 10cb96 <_Thread_Set_state+0x3a> <== NOT EXECUTED 0010cc34 <_Thread_Set_transient>: */ void _Thread_Set_transient( Thread_Control *the_thread ) { 10cc34: 55 push %ebp <== NOT EXECUTED 10cc35: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cc37: 56 push %esi <== NOT EXECUTED 10cc38: 53 push %ebx <== NOT EXECUTED 10cc39: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; uint32_t old_state; Chain_Control *ready; ready = the_thread->ready; 10cc3c: 8b 8b 8c 00 00 00 mov 0x8c(%ebx),%ecx <== NOT EXECUTED _ISR_Disable( level ); 10cc42: 9c pushf <== NOT EXECUTED 10cc43: fa cli <== NOT EXECUTED 10cc44: 5e pop %esi <== NOT EXECUTED old_state = the_thread->current_state; 10cc45: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED the_thread->current_state = _States_Set( STATES_TRANSIENT, old_state ); 10cc48: 89 d0 mov %edx,%eax <== NOT EXECUTED 10cc4a: 83 c8 04 or $0x4,%eax <== NOT EXECUTED 10cc4d: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED if ( _States_Is_ready( old_state ) ) { 10cc50: 85 d2 test %edx,%edx <== NOT EXECUTED 10cc52: 75 11 jne 10cc65 <_Thread_Set_transient+0x31> <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10cc54: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10cc56: 3b 41 08 cmp 0x8(%ecx),%eax <== NOT EXECUTED 10cc59: 74 11 je 10cc6c <_Thread_Set_transient+0x38> <== NOT EXECUTED 10cc5b: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10cc5d: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10cc60: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10cc63: 89 10 mov %edx,(%eax) <== NOT EXECUTED } else _Chain_Extract_unprotected( &the_thread->Object.Node ); } _ISR_Enable( level ); 10cc65: 56 push %esi <== NOT EXECUTED 10cc66: 9d popf <== NOT EXECUTED } 10cc67: 5b pop %ebx <== NOT EXECUTED 10cc68: 5e pop %esi <== NOT EXECUTED 10cc69: c9 leave <== NOT EXECUTED 10cc6a: c3 ret <== NOT EXECUTED 10cc6b: 90 nop <== NOT EXECUTED 10cc6c: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10cc6f: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10cc71: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10cc78: 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 10cc7b: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax <== NOT EXECUTED 10cc81: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx <== NOT EXECUTED 10cc88: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10cc8b: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10cc8f: 75 d4 jne 10cc65 <_Thread_Set_transient+0x31> <== NOT EXECUTED * to be resized 10cc91: 66 a1 b0 ea 11 00 mov 0x11eab0,%ax <== NOT EXECUTED 10cc97: 23 83 98 00 00 00 and 0x98(%ebx),%eax <== NOT EXECUTED 10cc9d: 66 a3 b0 ea 11 00 mov %ax,0x11eab0 <== NOT EXECUTED 10cca3: eb c0 jmp 10cc65 <_Thread_Set_transient+0x31> <== NOT EXECUTED 0010cca8 <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 10cca8: 55 push %ebp <== NOT EXECUTED 10cca9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ccab: 53 push %ebx <== NOT EXECUTED 10ccac: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10ccaf: a1 b0 a4 11 00 mov 0x11a4b0,%eax <== NOT EXECUTED 10ccb4: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10ccb7: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10ccb9: 73 02 jae 10ccbd <_Thread_Stack_Allocate+0x15> <== NOT EXECUTED 10ccbb: 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 ) { 10ccbd: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10ccc2: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED 10ccc5: 85 c0 test %eax,%eax <== NOT EXECUTED 10ccc7: 74 33 je 10ccfc <_Thread_Stack_Allocate+0x54> <== NOT EXECUTED stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size ); 10ccc9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cccc: 53 push %ebx <== NOT EXECUTED 10cccd: ff d0 call *%eax <== NOT EXECUTED 10cccf: 89 c2 mov %eax,%edx <== NOT EXECUTED 10ccd1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 10ccd4: 85 d2 test %edx,%edx <== NOT EXECUTED 10ccd6: 74 10 je 10cce8 <_Thread_Stack_Allocate+0x40> <== NOT EXECUTED the_stack_size = 0; the_thread->Start.stack = stack_addr; 10ccd8: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ccdb: 89 90 d0 00 00 00 mov %edx,0xd0(%eax) <== NOT EXECUTED return the_stack_size; } 10cce1: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10cce3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cce6: c9 leave <== NOT EXECUTED 10cce7: c3 ret <== NOT EXECUTED the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 10cce8: 31 db xor %ebx,%ebx <== NOT EXECUTED the_stack_size = 0; the_thread->Start.stack = stack_addr; 10ccea: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cced: 89 90 d0 00 00 00 mov %edx,0xd0(%eax) <== NOT EXECUTED return the_stack_size; } 10ccf3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10ccf5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ccf8: c9 leave <== NOT EXECUTED 10ccf9: c3 ret <== NOT EXECUTED 10ccfa: 66 90 xchg %ax,%ax <== 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 ); 10ccfc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ccff: 53 push %ebx <== NOT EXECUTED 10cd00: e8 d7 06 00 00 call 10d3dc <_Workspace_Allocate> <== NOT EXECUTED 10cd05: 89 c2 mov %eax,%edx <== NOT EXECUTED 10cd07: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cd0a: eb c8 jmp 10ccd4 <_Thread_Stack_Allocate+0x2c> <== NOT EXECUTED 0010cd0c <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 10cd0c: 55 push %ebp <== NOT EXECUTED 10cd0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cd0f: 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 ) 10cd12: 80 ba c0 00 00 00 00 cmpb $0x0,0xc0(%edx) <== NOT EXECUTED 10cd19: 74 19 je 10cd34 <_Thread_Stack_Free+0x28> <== 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 ) 10cd1b: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10cd20: 8b 48 24 mov 0x24(%eax),%ecx <== NOT EXECUTED 10cd23: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10cd25: 74 11 je 10cd38 <_Thread_Stack_Free+0x2c> <== NOT EXECUTED (*_Configuration_Table->stack_free_hook)( 10cd27: 8b 82 c8 00 00 00 mov 0xc8(%edx),%eax <== NOT EXECUTED 10cd2d: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10cd30: 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)( 10cd31: ff e1 jmp *%ecx <== NOT EXECUTED 10cd33: 90 nop <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10cd34: c9 leave <== NOT EXECUTED 10cd35: c3 ret <== NOT EXECUTED 10cd36: 66 90 xchg %ax,%ax <== 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 ); 10cd38: 8b 82 c8 00 00 00 mov 0xc8(%edx),%eax <== NOT EXECUTED 10cd3e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10cd41: 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 ); 10cd42: e9 7d 06 00 00 jmp 10d3c4 <_Workspace_Free> <== NOT EXECUTED 0010cda4 <_Thread_Start>: Thread_Start_types the_prototype, void *entry_point, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10cda4: 55 push %ebp <== NOT EXECUTED 10cda5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cda7: 53 push %ebx <== NOT EXECUTED 10cda8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10cdab: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( _States_Is_dormant( the_thread->current_state ) ) { 10cdae: f6 43 10 01 testb $0x1,0x10(%ebx) <== NOT EXECUTED 10cdb2: 75 08 jne 10cdbc <_Thread_Start+0x18> <== NOT EXECUTED 10cdb4: 31 c0 xor %eax,%eax <== NOT EXECUTED return true; } return false; } 10cdb6: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cdb9: c9 leave <== NOT EXECUTED 10cdba: c3 ret <== NOT EXECUTED 10cdbb: 90 nop <== NOT EXECUTED Thread_Entry_numeric_type numeric_argument ) { if ( _States_Is_dormant( the_thread->current_state ) ) { the_thread->Start.entry_point = (Thread_Entry) entry_point; 10cdbc: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10cdbf: 89 83 9c 00 00 00 mov %eax,0x9c(%ebx) <== NOT EXECUTED the_thread->Start.prototype = the_prototype; 10cdc5: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10cdc8: 89 83 a0 00 00 00 mov %eax,0xa0(%ebx) <== NOT EXECUTED the_thread->Start.pointer_argument = pointer_argument; 10cdce: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10cdd1: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) <== NOT EXECUTED the_thread->Start.numeric_argument = numeric_argument; 10cdd7: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10cdda: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) <== NOT EXECUTED _Thread_Load_environment( the_thread ); 10cde0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cde3: 53 push %ebx <== NOT EXECUTED 10cde4: e8 b3 26 00 00 call 10f49c <_Thread_Load_environment> <== NOT EXECUTED _Thread_Ready( the_thread ); 10cde9: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10cdec: e8 2f 29 00 00 call 10f720 <_Thread_Ready> <== NOT EXECUTED _User_extensions_Thread_start( the_thread ); 10cdf1: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10cdf4: e8 3f 03 00 00 call 10d138 <_User_extensions_Thread_start> <== NOT EXECUTED 10cdf9: b0 01 mov $0x1,%al <== NOT EXECUTED 10cdfb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return true; } return false; } 10cdfe: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ce01: c9 leave <== NOT EXECUTED 10ce02: c3 ret <== NOT EXECUTED 0010cd48 <_Thread_Start_multitasking>: * ready chain * select heir */ void _Thread_Start_multitasking( void ) { 10cd48: 55 push %ebp <== NOT EXECUTED 10cd49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cd4b: 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( 10cd4e: c7 05 c4 eb 11 00 03 movl $0x3,0x11ebc4 <== NOT EXECUTED 10cd55: 00 00 00 <== NOT EXECUTED * the system is shut down. */ _System_state_Set( SYSTEM_STATE_UP ); _Context_Switch_necessary = FALSE; 10cd58: c6 05 cc ea 11 00 00 movb $0x0,0x11eacc <== NOT EXECUTED _Thread_Executing = _Thread_Heir; 10cd5f: a1 88 ea 11 00 mov 0x11ea88,%eax <== NOT EXECUTED 10cd64: a3 bc ea 11 00 mov %eax,0x11eabc <== 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 ) 10cd69: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx <== NOT EXECUTED 10cd6f: 85 d2 test %edx,%edx <== NOT EXECUTED 10cd71: 74 16 je 10cd89 <_Thread_Start_multitasking+0x41> <== NOT EXECUTED _Context_Restore_fp( &_Thread_Heir->fp_context ); 10cd73: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cd76: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10cd7b: 50 push %eax <== NOT EXECUTED 10cd7c: e8 3d 07 00 00 call 10d4be <_CPU_Context_restore_fp> <== NOT EXECUTED 10cd81: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cd84: a1 88 ea 11 00 mov 0x11ea88,%eax <== NOT EXECUTED #endif _Context_Switch( &_Thread_BSP_context, &_Thread_Heir->Registers ); 10cd89: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10cd8c: 05 d4 00 00 00 add $0xd4,%eax <== NOT EXECUTED 10cd91: 50 push %eax <== NOT EXECUTED 10cd92: 68 e0 e9 11 00 push $0x11e9e0 <== NOT EXECUTED 10cd97: e8 e4 06 00 00 call 10d480 <_CPU_Context_switch> <== NOT EXECUTED 10cd9c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10cd9f: c9 leave <== NOT EXECUTED 10cda0: c3 ret <== NOT EXECUTED 0010e3ac <_Thread_Suspend>: */ void _Thread_Suspend( Thread_Control *the_thread ) { 10e3ac: 55 push %ebp <== NOT EXECUTED 10e3ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e3af: 56 push %esi <== NOT EXECUTED 10e3b0: 53 push %ebx <== NOT EXECUTED 10e3b1: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Chain_Control *ready; ready = the_thread->ready; 10e3b4: 8b 91 8c 00 00 00 mov 0x8c(%ecx),%edx <== NOT EXECUTED _ISR_Disable( level ); 10e3ba: 9c pushf <== NOT EXECUTED 10e3bb: fa cli <== NOT EXECUTED 10e3bc: 5b pop %ebx <== NOT EXECUTED the_thread->suspend_count++; 10e3bd: ff 41 70 incl 0x70(%ecx) <== NOT EXECUTED if ( !_States_Is_ready( the_thread->current_state ) ) { 10e3c0: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED 10e3c3: 85 c0 test %eax,%eax <== NOT EXECUTED 10e3c5: 75 31 jne 10e3f8 <_Thread_Suspend+0x4c> <== NOT EXECUTED _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); return; } the_thread->current_state = STATES_SUSPENDED; 10e3c7: c7 41 10 02 00 00 00 movl $0x2,0x10(%ecx) <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10e3ce: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10e3d0: 3b 42 08 cmp 0x8(%edx),%eax <== NOT EXECUTED 10e3d3: 74 2f je 10e404 <_Thread_Suspend+0x58> <== NOT EXECUTED 10e3d5: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10e3d7: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10e3da: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10e3dd: 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 ); 10e3df: 53 push %ebx <== NOT EXECUTED 10e3e0: 9d popf <== NOT EXECUTED 10e3e1: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) 10e3e2: 3b 0d e8 a5 12 00 cmp 0x12a5e8,%ecx <== NOT EXECUTED 10e3e8: 74 62 je 10e44c <_Thread_Suspend+0xa0> <== NOT EXECUTED _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) 10e3ea: 3b 0d 1c a6 12 00 cmp 0x12a61c,%ecx <== NOT EXECUTED 10e3f0: 74 4e je 10e440 <_Thread_Suspend+0x94> <== NOT EXECUTED _Context_Switch_necessary = TRUE; _ISR_Enable( level ); 10e3f2: 53 push %ebx <== NOT EXECUTED 10e3f3: 9d popf <== NOT EXECUTED } 10e3f4: 5b pop %ebx <== NOT EXECUTED 10e3f5: 5e pop %esi <== NOT EXECUTED 10e3f6: c9 leave <== NOT EXECUTED 10e3f7: c3 ret <== NOT EXECUTED ready = the_thread->ready; _ISR_Disable( level ); the_thread->suspend_count++; if ( !_States_Is_ready( the_thread->current_state ) ) { the_thread->current_state = 10e3f8: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 10e3fb: 89 41 10 mov %eax,0x10(%ecx) <== NOT EXECUTED _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); 10e3fe: 53 push %ebx <== NOT EXECUTED 10e3ff: 9d popf <== NOT EXECUTED if ( _Thread_Is_executing( the_thread ) ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10e400: 5b pop %ebx <== NOT EXECUTED 10e401: 5e pop %esi <== NOT EXECUTED 10e402: c9 leave <== NOT EXECUTED 10e403: c3 ret <== NOT EXECUTED 10e404: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10e407: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10e409: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10e410: 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 10e413: 8b 81 90 00 00 00 mov 0x90(%ecx),%eax <== NOT EXECUTED 10e419: 66 8b 91 9a 00 00 00 mov 0x9a(%ecx),%dx <== NOT EXECUTED 10e420: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10e423: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10e427: 75 b6 jne 10e3df <_Thread_Suspend+0x33> <== NOT EXECUTED * to be resized 10e429: 66 a1 10 a6 12 00 mov 0x12a610,%ax <== NOT EXECUTED 10e42f: 23 81 98 00 00 00 and 0x98(%ecx),%eax <== NOT EXECUTED 10e435: 66 a3 10 a6 12 00 mov %ax,0x12a610 <== NOT EXECUTED 10e43b: eb a2 jmp 10e3df <_Thread_Suspend+0x33> <== NOT EXECUTED 10e43d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) _Context_Switch_necessary = TRUE; 10e440: c6 05 2c a6 12 00 01 movb $0x1,0x12a62c <== NOT EXECUTED 10e447: eb a9 jmp 10e3f2 <_Thread_Suspend+0x46> <== NOT EXECUTED 10e449: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10e44c: 66 8b 35 10 a6 12 00 mov 0x12a610,%si <== NOT EXECUTED 10e453: 31 d2 xor %edx,%edx <== NOT EXECUTED 10e455: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e457: 66 0f bc c6 bsf %si,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10e45b: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10e45e: 66 8b b4 00 a0 a6 12 mov 0x12a6a0(%eax,%eax,1),%si <== NOT EXECUTED 10e465: 00 <== NOT EXECUTED 10e466: 66 0f bc d6 bsf %si,%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. 10e46a: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10e46d: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10e470: 01 d0 add %edx,%eax <== NOT EXECUTED 10e472: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10e475: 8b 15 20 a5 12 00 mov 0x12a520,%edx <== NOT EXECUTED 10e47b: 8b 04 82 mov (%edx,%eax,4),%eax <== NOT EXECUTED 10e47e: a3 e8 a5 12 00 mov %eax,0x12a5e8 <== NOT EXECUTED 10e483: e9 62 ff ff ff jmp 10e3ea <_Thread_Suspend+0x3e> <== NOT EXECUTED 0010ce04 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10ce04: 55 push %ebp <== NOT EXECUTED 10ce05: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ce07: 53 push %ebx <== NOT EXECUTED 10ce08: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 10ce0b: 8b 1d bc ea 11 00 mov 0x11eabc,%ebx <== NOT EXECUTED /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10ce11: 80 7b 76 00 cmpb $0x0,0x76(%ebx) <== NOT EXECUTED 10ce15: 74 19 je 10ce30 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED return; if ( !_States_Is_ready( executing->current_state ) ) 10ce17: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10ce1a: 85 c0 test %eax,%eax <== NOT EXECUTED 10ce1c: 75 12 jne 10ce30 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10ce1e: 8b 43 7c mov 0x7c(%ebx),%eax <== NOT EXECUTED 10ce21: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10ce24: 72 0a jb 10ce30 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED 10ce26: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10ce29: 76 29 jbe 10ce54 <_Thread_Tickle_timeslice+0x50> <== NOT EXECUTED 10ce2b: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10ce2e: 74 08 je 10ce38 <_Thread_Tickle_timeslice+0x34> <== NOT EXECUTED case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) (*executing->budget_callout)( executing ); break; } } 10ce30: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ce33: c9 leave <== NOT EXECUTED 10ce34: c3 ret <== NOT EXECUTED 10ce35: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED executing->cpu_time_budget = _Thread_Ticks_per_timeslice; } break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 10ce38: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 10ce3b: 48 dec %eax <== NOT EXECUTED 10ce3c: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10ce3f: 85 c0 test %eax,%eax <== NOT EXECUTED 10ce41: 75 ed jne 10ce30 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED (*executing->budget_callout)( executing ); 10ce43: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ce46: 53 push %ebx <== NOT EXECUTED 10ce47: ff 93 80 00 00 00 call *0x80(%ebx) <== NOT EXECUTED 10ce4d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ce50: eb de jmp 10ce30 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED 10ce52: 66 90 xchg %ax,%ax <== 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 ) { 10ce54: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 10ce57: 48 dec %eax <== NOT EXECUTED 10ce58: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10ce5b: 85 c0 test %eax,%eax <== NOT EXECUTED 10ce5d: 7f d1 jg 10ce30 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED _Thread_Reset_timeslice(); 10ce5f: e8 5c 29 00 00 call 10f7c0 <_Thread_Reset_timeslice> <== NOT EXECUTED executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10ce64: a1 c4 e9 11 00 mov 0x11e9c4,%eax <== NOT EXECUTED 10ce69: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10ce6c: eb c2 jmp 10ce30 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED 0010ce70 <_Thread_Yield_processor>: * ready chain * select heir */ void _Thread_Yield_processor( void ) { 10ce70: 55 push %ebp <== NOT EXECUTED 10ce71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ce73: 56 push %esi <== NOT EXECUTED 10ce74: 53 push %ebx <== NOT EXECUTED ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10ce75: 8b 0d bc ea 11 00 mov 0x11eabc,%ecx <== NOT EXECUTED ready = executing->ready; 10ce7b: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx <== NOT EXECUTED _ISR_Disable( level ); 10ce81: 9c pushf <== NOT EXECUTED 10ce82: fa cli <== NOT EXECUTED 10ce83: 5e pop %esi <== NOT EXECUTED if ( !_Chain_Has_only_one_node( ready ) ) { 10ce84: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10ce86: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10ce89: 74 35 je 10cec0 <_Thread_Yield_processor+0x50> <== NOT EXECUTED 10ce8b: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10ce8d: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10ce90: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10ce93: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10ce95: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 10ce98: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10ce9a: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10ce9d: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED 10cea0: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10cea2: 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 ); 10cea5: 56 push %esi <== NOT EXECUTED 10cea6: 9d popf <== NOT EXECUTED 10cea7: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( executing ) ) 10cea8: 3b 0d 88 ea 11 00 cmp 0x11ea88,%ecx <== NOT EXECUTED 10ceae: 74 1c je 10cecc <_Thread_Yield_processor+0x5c> <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; } else if ( !_Thread_Is_heir( executing ) ) _Context_Switch_necessary = TRUE; 10ceb0: c6 05 cc ea 11 00 01 movb $0x1,0x11eacc <== NOT EXECUTED _ISR_Enable( level ); 10ceb7: 56 push %esi <== NOT EXECUTED 10ceb8: 9d popf <== NOT EXECUTED } 10ceb9: 5b pop %ebx <== NOT EXECUTED 10ceba: 5e pop %esi <== NOT EXECUTED 10cebb: c9 leave <== NOT EXECUTED 10cebc: c3 ret <== NOT EXECUTED 10cebd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; } else if ( !_Thread_Is_heir( executing ) ) 10cec0: 3b 0d 88 ea 11 00 cmp 0x11ea88,%ecx <== NOT EXECUTED 10cec6: 75 e8 jne 10ceb0 <_Thread_Yield_processor+0x40> <== NOT EXECUTED 10cec8: eb ed jmp 10ceb7 <_Thread_Yield_processor+0x47> <== NOT EXECUTED 10ceca: 66 90 xchg %ax,%ax <== NOT EXECUTED _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) ready->first; 10cecc: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10cece: a3 88 ea 11 00 mov %eax,0x11ea88 <== NOT EXECUTED 10ced3: eb db jmp 10ceb0 <_Thread_Yield_processor+0x40> <== NOT EXECUTED 0010bd80 <_Thread_blocking_operation_Cancel>: void _Thread_blocking_operation_Cancel( Thread_blocking_operation_States sync_state, Thread_Control *the_thread, ISR_Level level ) { 10bd80: 55 push %ebp <== NOT EXECUTED 10bd81: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd83: 53 push %ebx <== NOT EXECUTED 10bd84: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bd87: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10bd8a: 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; 10bd8d: 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 ) ) { 10bd94: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10bd98: 74 16 je 10bdb0 <_Thread_blocking_operation_Cancel+0x30> <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); (void) _Watchdog_Remove( &the_thread->Timer ); } else _ISR_Enable( level ); 10bd9a: 50 push %eax <== NOT EXECUTED 10bd9b: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10bd9c: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 10bda3: 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 } 10bda6: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bda9: c9 leave <== NOT EXECUTED 10bdaa: e9 51 01 00 00 jmp 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 10bdaf: 90 nop <== 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 */ 10bdb0: c7 43 50 03 00 00 00 movl $0x3,0x50(%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 ) ) { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10bdb7: 50 push %eax <== NOT EXECUTED 10bdb8: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10bdb9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bdbc: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10bdbf: 50 push %eax <== NOT EXECUTED 10bdc0: e8 23 15 00 00 call 10d2e8 <_Watchdog_Remove> <== NOT EXECUTED 10bdc5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bdc8: eb d2 jmp 10bd9c <_Thread_blocking_operation_Cancel+0x1c> <== NOT EXECUTED 0010c62c <_Thread_queue_Dequeue>: */ Thread_Control *_Thread_queue_Dequeue( Thread_queue_Control *the_thread_queue ) { 10c62c: 55 push %ebp <== NOT EXECUTED 10c62d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c62f: 53 push %ebx <== NOT EXECUTED 10c630: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10c633: 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 ) 10c636: 83 7b 34 01 cmpl $0x1,0x34(%ebx) <== NOT EXECUTED 10c63a: 74 20 je 10c65c <_Thread_queue_Dequeue+0x30> <== NOT EXECUTED 10c63c: b8 24 f5 10 00 mov $0x10f524,%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 ); 10c641: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c644: 53 push %ebx <== NOT EXECUTED 10c645: ff d0 call *%eax <== NOT EXECUTED 10c647: 89 c2 mov %eax,%edx <== NOT EXECUTED _ISR_Disable( level ); 10c649: 9c pushf <== NOT EXECUTED 10c64a: fa cli <== NOT EXECUTED 10c64b: 59 pop %ecx <== NOT EXECUTED if ( !the_thread ) { 10c64c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c64f: 85 c0 test %eax,%eax <== NOT EXECUTED 10c651: 74 11 je 10c664 <_Thread_queue_Dequeue+0x38> <== NOT EXECUTED (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; the_thread = _Thread_Executing; } } _ISR_Enable( level ); 10c653: 51 push %ecx <== NOT EXECUTED 10c654: 9d popf <== NOT EXECUTED return the_thread; } 10c655: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c657: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c65a: c9 leave <== NOT EXECUTED 10c65b: c3 ret <== 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 ) 10c65c: b8 7c c6 10 00 mov $0x10c67c,%eax <== NOT EXECUTED 10c661: eb de jmp 10c641 <_Thread_queue_Dequeue+0x15> <== NOT EXECUTED 10c663: 90 nop <== NOT EXECUTED the_thread = (*dequeue_p)( the_thread_queue ); _ISR_Disable( level ); if ( !the_thread ) { sync_state = the_thread_queue->sync_state; if ( (sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 10c664: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10c667: 48 dec %eax <== NOT EXECUTED 10c668: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10c66b: 77 e6 ja 10c653 <_Thread_queue_Dequeue+0x27> <== NOT EXECUTED (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 10c66d: c7 43 30 03 00 00 00 movl $0x3,0x30(%ebx) <== NOT EXECUTED the_thread = _Thread_Executing; 10c674: 8b 15 bc ea 11 00 mov 0x11eabc,%edx <== NOT EXECUTED 10c67a: eb d7 jmp 10c653 <_Thread_queue_Dequeue+0x27> <== NOT EXECUTED 0010f524 <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 10f524: 55 push %ebp <== NOT EXECUTED 10f525: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f527: 56 push %esi <== NOT EXECUTED 10f528: 53 push %ebx <== NOT EXECUTED 10f529: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); 10f52c: 9c pushf <== NOT EXECUTED 10f52d: fa cli <== NOT EXECUTED 10f52e: 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( 10f52f: 8b 11 mov (%ecx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 10f531: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10f534: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10f536: 74 62 je 10f59a <_Thread_queue_Dequeue_fifo+0x76> <== NOT EXECUTED 10f538: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10f53a: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10f53c: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED the_thread = (Thread_Control *) 10f53f: 89 d3 mov %edx,%ebx <== NOT EXECUTED _Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo ); the_thread->Wait.queue = NULL; 10f541: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10f548: 83 7a 50 02 cmpl $0x2,0x50(%edx) <== NOT EXECUTED 10f54c: 74 1e je 10f56c <_Thread_queue_Dequeue_fifo+0x48> <== NOT EXECUTED _ISR_Enable( level ); 10f54e: 56 push %esi <== NOT EXECUTED 10f54f: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10f550: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f553: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10f558: 52 push %edx <== NOT EXECUTED 10f559: e8 a2 c9 ff ff call 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 10f55e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return the_thread; } _ISR_Enable( level ); return NULL; } 10f561: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10f563: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f566: 5b pop %ebx <== NOT EXECUTED 10f567: 5e pop %esi <== NOT EXECUTED 10f568: c9 leave <== NOT EXECUTED 10f569: c3 ret <== NOT EXECUTED 10f56a: 66 90 xchg %ax,%ax <== 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 */ 10f56c: c7 42 50 03 00 00 00 movl $0x3,0x50(%edx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10f573: 56 push %esi <== NOT EXECUTED 10f574: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10f575: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f578: 8d 42 48 lea 0x48(%edx),%eax <== NOT EXECUTED 10f57b: 50 push %eax <== NOT EXECUTED 10f57c: e8 67 dd ff ff call 10d2e8 <_Watchdog_Remove> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10f581: 58 pop %eax <== NOT EXECUTED 10f582: 5a pop %edx <== NOT EXECUTED 10f583: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10f588: 53 push %ebx <== NOT EXECUTED 10f589: e8 72 c9 ff ff call 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 10f58e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return the_thread; } _ISR_Enable( level ); return NULL; } 10f591: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10f593: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f596: 5b pop %ebx <== NOT EXECUTED 10f597: 5e pop %esi <== NOT EXECUTED 10f598: c9 leave <== NOT EXECUTED 10f599: c3 ret <== NOT EXECUTED #endif return the_thread; } _ISR_Enable( level ); 10f59a: 56 push %esi <== NOT EXECUTED 10f59b: 9d popf <== NOT EXECUTED 10f59c: 31 db xor %ebx,%ebx <== NOT EXECUTED 10f59e: eb c1 jmp 10f561 <_Thread_queue_Dequeue_fifo+0x3d> <== NOT EXECUTED 0010c67c <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 10c67c: 55 push %ebp <== NOT EXECUTED 10c67d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c67f: 57 push %edi <== NOT EXECUTED 10c680: 56 push %esi <== NOT EXECUTED 10c681: 53 push %ebx <== NOT EXECUTED 10c682: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c685: 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 ); 10c688: 9c pushf <== NOT EXECUTED 10c689: fa cli <== NOT EXECUTED 10c68a: 5f pop %edi <== NOT EXECUTED 10c68b: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c68d: 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( 10c68f: 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 ] ) ) { 10c692: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10c695: 8d 44 86 04 lea 0x4(%esi,%eax,4),%eax <== NOT EXECUTED 10c699: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10c69b: 75 1f jne 10c6bc <_Thread_queue_Dequeue_priority+0x40> <== NOT EXECUTED Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 10c69d: 42 inc %edx <== NOT EXECUTED 10c69e: 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 ; 10c6a1: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10c6a4: 75 e9 jne 10c68f <_Thread_queue_Dequeue_priority+0x13> <== NOT EXECUTED } /* * We did not find a thread to unblock. */ _ISR_Enable( level ); 10c6a6: 57 push %edi <== NOT EXECUTED 10c6a7: 9d popf <== NOT EXECUTED 10c6a8: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp) <== 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 ); } 10c6af: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10c6b2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c6b5: 5b pop %ebx <== NOT EXECUTED 10c6b6: 5e pop %esi <== NOT EXECUTED 10c6b7: 5f pop %edi <== NOT EXECUTED 10c6b8: c9 leave <== NOT EXECUTED 10c6b9: c3 ret <== NOT EXECUTED 10c6ba: 66 90 xchg %ax,%ax <== NOT EXECUTED _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) { the_thread = (Thread_Control *) 10c6bc: 89 5d e8 mov %ebx,-0x18(%ebp) <== NOT EXECUTED */ _ISR_Enable( level ); return NULL; dequeue: the_thread->Wait.queue = NULL; 10c6bf: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED new_first_node = the_thread->Wait.Block2n.first; 10c6c6: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; 10c6c9: 8b 33 mov (%ebx),%esi <== NOT EXECUTED previous_node = the_thread->Object.Node.previous; 10c6cb: 8b 4b 04 mov 0x4(%ebx),%ecx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10c6ce: 8d 43 3c lea 0x3c(%ebx),%eax <== NOT EXECUTED 10c6d1: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10c6d3: 0f 84 85 00 00 00 je 10c75e <_Thread_queue_Dequeue_priority+0xe2> <== NOT EXECUTED last_node = the_thread->Wait.Block2n.last; 10c6d9: 8b 43 40 mov 0x40(%ebx),%eax <== NOT EXECUTED 10c6dc: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED new_second_node = new_first_node->next; 10c6df: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10c6e1: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED previous_node->next = new_first_node; 10c6e4: 89 11 mov %edx,(%ecx) <== NOT EXECUTED next_node->previous = new_first_node; 10c6e6: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED new_first_node->next = next_node; 10c6e9: 89 32 mov %esi,(%edx) <== NOT EXECUTED new_first_node->previous = previous_node; 10c6eb: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10c6ee: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10c6f1: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 10c6f4: 74 1a je 10c710 <_Thread_queue_Dequeue_priority+0x94> <== NOT EXECUTED /* > two threads on 2-n */ new_second_node->previous = 10c6f6: 8d 42 38 lea 0x38(%edx),%eax <== NOT EXECUTED 10c6f9: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 10c6fc: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 10c6ff: 89 4a 38 mov %ecx,0x38(%edx) <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 10c702: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10c705: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10c708: 8d 42 3c lea 0x3c(%edx),%eax <== NOT EXECUTED 10c70b: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10c70e: 89 02 mov %eax,(%edx) <== NOT EXECUTED } else { previous_node->next = next_node; next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10c710: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10c714: 74 1e je 10c734 <_Thread_queue_Dequeue_priority+0xb8> <== NOT EXECUTED _ISR_Enable( level ); 10c716: 57 push %edi <== NOT EXECUTED 10c717: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10c718: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c71b: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10c720: 53 push %ebx <== NOT EXECUTED 10c721: e8 da f7 ff ff call 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 10c726: 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 ); } 10c729: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10c72c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c72f: 5b pop %ebx <== NOT EXECUTED 10c730: 5e pop %esi <== NOT EXECUTED 10c731: 5f pop %edi <== NOT EXECUTED 10c732: c9 leave <== NOT EXECUTED 10c733: c3 ret <== 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 */ 10c734: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10c73b: 57 push %edi <== NOT EXECUTED 10c73c: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10c73d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c740: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10c743: 50 push %eax <== NOT EXECUTED 10c744: e8 9f 0b 00 00 call 10d2e8 <_Watchdog_Remove> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10c749: 58 pop %eax <== NOT EXECUTED 10c74a: 5a pop %edx <== NOT EXECUTED 10c74b: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10c750: 53 push %ebx <== NOT EXECUTED 10c751: e8 aa f7 ff ff call 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 10c756: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c759: e9 51 ff ff ff jmp 10c6af <_Thread_queue_Dequeue_priority+0x33> <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); } } else { previous_node->next = next_node; 10c75e: 89 31 mov %esi,(%ecx) <== NOT EXECUTED next_node->previous = previous_node; 10c760: 89 4e 04 mov %ecx,0x4(%esi) <== NOT EXECUTED 10c763: eb ab jmp 10c710 <_Thread_queue_Dequeue_priority+0x94> <== NOT EXECUTED 0010f5a0 <_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 ) { 10f5a0: 55 push %ebp <== NOT EXECUTED 10f5a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f5a3: 56 push %esi <== NOT EXECUTED 10f5a4: 53 push %ebx <== NOT EXECUTED 10f5a5: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10f5a8: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Thread_blocking_operation_States sync_state; ISR_Level level; _ISR_Disable( level ); 10f5ab: 9c pushf <== NOT EXECUTED 10f5ac: fa cli <== NOT EXECUTED 10f5ad: 5e pop %esi <== NOT EXECUTED sync_state = the_thread_queue->sync_state; 10f5ae: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10f5b1: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) <== NOT EXECUTED if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) { 10f5b8: 83 f9 01 cmp $0x1,%ecx <== NOT EXECUTED 10f5bb: 74 0b je 10f5c8 <_Thread_queue_Enqueue_fifo+0x28> <== 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; 10f5bd: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10f5c0: 89 30 mov %esi,(%eax) <== NOT EXECUTED return sync_state; } 10f5c2: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10f5c4: 5b pop %ebx <== NOT EXECUTED 10f5c5: 5e pop %esi <== NOT EXECUTED 10f5c6: c9 leave <== NOT EXECUTED 10f5c7: c3 ret <== NOT EXECUTED 10f5c8: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10f5cb: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10f5cd: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10f5d0: 89 5a 08 mov %ebx,0x8(%edx) <== NOT EXECUTED 10f5d3: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10f5d5: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) { _Chain_Append_unprotected( &the_thread_queue->Queues.Fifo, &the_thread->Object.Node ); the_thread->Wait.queue = the_thread_queue; 10f5d8: 89 53 44 mov %edx,0x44(%ebx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; _ISR_Enable( level ); 10f5db: 56 push %esi <== NOT EXECUTED 10f5dc: 9d popf <== NOT EXECUTED * * WARNING! Returning with interrupts disabled! */ *level_p = level; return sync_state; } 10f5dd: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10f5df: 5b pop %ebx <== NOT EXECUTED 10f5e0: 5e pop %esi <== NOT EXECUTED 10f5e1: c9 leave <== NOT EXECUTED 10f5e2: c3 ret <== NOT EXECUTED 0010c800 <_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 ) { 10c800: 55 push %ebp <== NOT EXECUTED 10c801: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c803: 57 push %edi <== NOT EXECUTED 10c804: 56 push %esi <== NOT EXECUTED 10c805: 53 push %ebx <== NOT EXECUTED 10c806: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c809: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c80c: 83 c0 3c add $0x3c,%eax <== NOT EXECUTED 10c80f: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10c812: 89 42 38 mov %eax,0x38(%edx) <== NOT EXECUTED 10c815: c7 42 3c 00 00 00 00 movl $0x0,0x3c(%edx) <== NOT EXECUTED 10c81c: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c81e: 83 c0 38 add $0x38,%eax <== NOT EXECUTED 10c821: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 10c824: 8b 5a 14 mov 0x14(%edx),%ebx <== 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. 10c827: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c829: c1 e8 06 shr $0x6,%eax <== NOT EXECUTED header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; block_state = the_thread_queue->state; 10c82c: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c82f: 8b 49 38 mov 0x38(%ecx),%ecx <== NOT EXECUTED 10c832: 89 4d f0 mov %ecx,-0x10(%ebp) <== NOT EXECUTED if ( _Thread_queue_Is_reverse_search( priority ) ) 10c835: f6 c3 20 test $0x20,%bl <== NOT EXECUTED 10c838: 75 66 jne 10c8a0 <_Thread_queue_Enqueue_priority+0xa0> <== 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 10c83a: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10c83d: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10c840: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c843: 8d 7c 02 04 lea 0x4(%edx,%eax,1),%edi <== NOT EXECUTED goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; 10c847: 89 45 e8 mov %eax,-0x18(%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 ); 10c84a: 9c pushf <== NOT EXECUTED 10c84b: fa cli <== NOT EXECUTED 10c84c: 5e pop %esi <== NOT EXECUTED search_thread = (Thread_Control *) header->first; 10c84d: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10c850: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c853: 8b 14 08 mov (%eax,%ecx,1),%edx <== NOT EXECUTED while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10c856: 39 fa cmp %edi,%edx <== NOT EXECUTED 10c858: 75 1b jne 10c875 <_Thread_queue_Enqueue_priority+0x75> <== NOT EXECUTED 10c85a: e9 1a 01 00 00 jmp 10c979 <_Thread_queue_Enqueue_priority+0x179> <== NOT EXECUTED 10c85f: 90 nop <== NOT EXECUTED break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10c860: 56 push %esi <== NOT EXECUTED 10c861: 9d popf <== NOT EXECUTED 10c862: fa cli <== NOT EXECUTED if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c863: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10c866: 85 42 10 test %eax,0x10(%edx) <== NOT EXECUTED 10c869: 0f 84 ad 00 00 00 je 10c91c <_Thread_queue_Enqueue_priority+0x11c> <== NOT EXECUTED _ISR_Enable( level ); goto restart_forward_search; } search_thread = 10c86f: 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 ) ) { 10c871: 39 fa cmp %edi,%edx <== NOT EXECUTED 10c873: 74 07 je 10c87c <_Thread_queue_Enqueue_priority+0x7c> <== NOT EXECUTED search_priority = search_thread->current_priority; 10c875: 8b 4a 14 mov 0x14(%edx),%ecx <== NOT EXECUTED if ( priority <= search_priority ) 10c878: 39 cb cmp %ecx,%ebx <== NOT EXECUTED 10c87a: 77 e4 ja 10c860 <_Thread_queue_Enqueue_priority+0x60> <== 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 ) ) { 10c87c: 89 d7 mov %edx,%edi <== NOT EXECUTED } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10c87e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c881: 83 78 30 01 cmpl $0x1,0x30(%eax) <== NOT EXECUTED 10c885: 0f 84 99 00 00 00 je 10c924 <_Thread_queue_Enqueue_priority+0x124> <== 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; 10c88b: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10c88e: 89 30 mov %esi,(%eax) <== NOT EXECUTED return the_thread_queue->sync_state; 10c890: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c893: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED } 10c896: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c899: 5b pop %ebx <== NOT EXECUTED 10c89a: 5e pop %esi <== NOT EXECUTED 10c89b: 5f pop %edi <== NOT EXECUTED 10c89c: c9 leave <== NOT EXECUTED 10c89d: c3 ret <== NOT EXECUTED 10c89e: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node->previous = previous_node; previous_node->next = the_node; search_node->previous = the_node; the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10c8a0: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10c8a3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c8a6: 8d 0c 82 lea (%edx,%eax,4),%ecx <== NOT EXECUTED restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; 10c8a9: 8d 79 08 lea 0x8(%ecx),%edi <== NOT EXECUTED 10c8ac: 89 7d ec mov %edi,-0x14(%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; 10c8af: 0f b6 05 b4 a4 11 00 movzbl 0x11a4b4,%eax <== NOT EXECUTED 10c8b6: 40 inc %eax <== NOT EXECUTED _ISR_Disable( level ); 10c8b7: 9c pushf <== NOT EXECUTED 10c8b8: fa cli <== NOT EXECUTED 10c8b9: 5e pop %esi <== NOT EXECUTED search_thread = (Thread_Control *) header->last; 10c8ba: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 10c8bd: 8b 17 mov (%edi),%edx <== NOT EXECUTED while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10c8bf: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 10c8c1: 75 17 jne 10c8da <_Thread_queue_Enqueue_priority+0xda> <== NOT EXECUTED 10c8c3: eb 1c jmp 10c8e1 <_Thread_queue_Enqueue_priority+0xe1> <== NOT EXECUTED 10c8c5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 10c8c8: 56 push %esi <== NOT EXECUTED 10c8c9: 9d popf <== NOT EXECUTED 10c8ca: fa cli <== NOT EXECUTED if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c8cb: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 10c8ce: 85 7a 10 test %edi,0x10(%edx) <== NOT EXECUTED 10c8d1: 74 45 je 10c918 <_Thread_queue_Enqueue_priority+0x118> <== NOT EXECUTED _ISR_Enable( level ); goto restart_reverse_search; } search_thread = (Thread_Control *) 10c8d3: 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 ) ) { 10c8d6: 39 ca cmp %ecx,%edx <== NOT EXECUTED 10c8d8: 74 07 je 10c8e1 <_Thread_queue_Enqueue_priority+0xe1> <== NOT EXECUTED search_priority = search_thread->current_priority; 10c8da: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED if ( priority >= search_priority ) 10c8dd: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10c8df: 72 e7 jb 10c8c8 <_Thread_queue_Enqueue_priority+0xc8> <== 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 ) ) { 10c8e1: 89 d7 mov %edx,%edi <== NOT EXECUTED } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10c8e3: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c8e6: 83 79 30 01 cmpl $0x1,0x30(%ecx) <== NOT EXECUTED 10c8ea: 75 9f jne 10c88b <_Thread_queue_Enqueue_priority+0x8b> <== NOT EXECUTED THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c8ec: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) <== NOT EXECUTED if ( priority == search_priority ) 10c8f3: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10c8f5: 74 5d je 10c954 <_Thread_queue_Enqueue_priority+0x154> <== NOT EXECUTED goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10c8f7: 8b 02 mov (%edx),%eax <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10c8f9: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10c8fc: 89 07 mov %eax,(%edi) <== NOT EXECUTED the_node->previous = search_node; 10c8fe: 89 57 04 mov %edx,0x4(%edi) <== NOT EXECUTED search_node->next = the_node; 10c901: 89 3a mov %edi,(%edx) <== NOT EXECUTED next_node->previous = the_node; 10c903: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10c906: 89 4f 44 mov %ecx,0x44(%edi) <== NOT EXECUTED _ISR_Enable( level ); 10c909: 56 push %esi <== NOT EXECUTED 10c90a: 9d popf <== NOT EXECUTED 10c90b: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10c910: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c913: 5b pop %ebx <== NOT EXECUTED 10c914: 5e pop %esi <== NOT EXECUTED 10c915: 5f pop %edi <== NOT EXECUTED 10c916: c9 leave <== NOT EXECUTED 10c917: c3 ret <== NOT EXECUTED if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 10c918: 56 push %esi <== NOT EXECUTED 10c919: 9d popf <== NOT EXECUTED 10c91a: eb 93 jmp 10c8af <_Thread_queue_Enqueue_priority+0xaf> <== NOT EXECUTED if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 10c91c: 56 push %esi <== NOT EXECUTED 10c91d: 9d popf <== NOT EXECUTED 10c91e: e9 27 ff ff ff jmp 10c84a <_Thread_queue_Enqueue_priority+0x4a> <== NOT EXECUTED 10c923: 90 nop <== NOT EXECUTED if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c924: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) <== NOT EXECUTED if ( priority == search_priority ) 10c92b: 39 cb cmp %ecx,%ebx <== NOT EXECUTED 10c92d: 74 25 je 10c954 <_Thread_queue_Enqueue_priority+0x154> <== NOT EXECUTED goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10c92f: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c932: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10c935: 89 11 mov %edx,(%ecx) <== NOT EXECUTED the_node->previous = previous_node; 10c937: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED previous_node->next = the_node; 10c93a: 89 08 mov %ecx,(%eax) <== NOT EXECUTED search_node->previous = the_node; 10c93c: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10c93f: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10c942: 89 79 44 mov %edi,0x44(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10c945: 56 push %esi <== NOT EXECUTED 10c946: 9d popf <== NOT EXECUTED 10c947: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10c94c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c94f: 5b pop %ebx <== NOT EXECUTED 10c950: 5e pop %esi <== NOT EXECUTED 10c951: 5f pop %edi <== NOT EXECUTED 10c952: c9 leave <== NOT EXECUTED 10c953: c3 ret <== NOT EXECUTED 10c954: 8d 47 3c lea 0x3c(%edi),%eax <== NOT EXECUTED _ISR_Enable( level ); 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; 10c957: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c95a: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10c95d: 89 01 mov %eax,(%ecx) <== NOT EXECUTED the_node->previous = previous_node; 10c95f: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED previous_node->next = the_node; 10c962: 89 0a mov %ecx,(%edx) <== NOT EXECUTED search_node->previous = the_node; 10c964: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10c967: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10c96a: 89 79 44 mov %edi,0x44(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10c96d: 56 push %esi <== NOT EXECUTED 10c96e: 9d popf <== NOT EXECUTED 10c96f: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10c974: e9 1d ff ff ff jmp 10c896 <_Thread_queue_Enqueue_priority+0x96> <== 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 ) ) { 10c979: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 10c97e: e9 fb fe ff ff jmp 10c87e <_Thread_queue_Enqueue_priority+0x7e> <== NOT EXECUTED 0010c768 <_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 ) { 10c768: 55 push %ebp <== NOT EXECUTED 10c769: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c76b: 57 push %edi <== NOT EXECUTED 10c76c: 56 push %esi <== NOT EXECUTED 10c76d: 53 push %ebx <== NOT EXECUTED 10c76e: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 10c771: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10c774: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Thread_queue_Control *, Thread_Control *, ISR_Level * ); the_thread = _Thread_Executing; 10c777: 8b 1d bc ea 11 00 mov 0x11eabc,%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 ); 10c77d: ff 76 38 pushl 0x38(%esi) <== NOT EXECUTED 10c780: 53 push %ebx <== NOT EXECUTED 10c781: e8 d6 03 00 00 call 10cb5c <_Thread_Set_state> <== NOT EXECUTED /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { 10c786: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c789: 85 ff test %edi,%edi <== NOT EXECUTED 10c78b: 75 33 jne 10c7c0 <_Thread_queue_Enqueue_with_handler+0x58> <== NOT EXECUTED } /* * Now enqueue the thread per the discipline for this thread queue. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 10c78d: 83 7e 34 01 cmpl $0x1,0x34(%esi) <== NOT EXECUTED 10c791: 74 64 je 10c7f7 <_Thread_queue_Enqueue_with_handler+0x8f> <== NOT EXECUTED 10c793: ba a0 f5 10 00 mov $0x10f5a0,%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 ); 10c798: 51 push %ecx <== NOT EXECUTED 10c799: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10c79c: 50 push %eax <== NOT EXECUTED 10c79d: 53 push %ebx <== NOT EXECUTED 10c79e: 56 push %esi <== NOT EXECUTED 10c79f: ff d2 call *%edx <== NOT EXECUTED if ( sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 10c7a1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c7a4: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10c7a7: 74 0e je 10c7b7 <_Thread_queue_Enqueue_with_handler+0x4f> <== NOT EXECUTED _Thread_blocking_operation_Cancel( sync_state, the_thread, level ); 10c7a9: 52 push %edx <== NOT EXECUTED 10c7aa: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10c7ad: 53 push %ebx <== NOT EXECUTED 10c7ae: 50 push %eax <== NOT EXECUTED 10c7af: e8 cc f5 ff ff call 10bd80 <_Thread_blocking_operation_Cancel> <== NOT EXECUTED 10c7b4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10c7b7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c7ba: 5b pop %ebx <== NOT EXECUTED 10c7bb: 5e pop %esi <== NOT EXECUTED 10c7bc: 5f pop %edi <== NOT EXECUTED 10c7bd: c9 leave <== NOT EXECUTED 10c7be: c3 ret <== NOT EXECUTED 10c7bf: 90 nop <== NOT EXECUTED /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { _Watchdog_Initialize( 10c7c0: 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. * 10c7c3: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10c7ca: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10c7cd: 89 53 64 mov %edx,0x64(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10c7d0: 89 43 68 mov %eax,0x68(%ebx) <== NOT EXECUTED * the heap 10c7d3: 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, 10c7da: 89 7b 54 mov %edi,0x54(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10c7dd: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c7e0: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10c7e3: 50 push %eax <== NOT EXECUTED 10c7e4: 68 dc ea 11 00 push $0x11eadc <== NOT EXECUTED 10c7e9: e8 ca 09 00 00 call 10d1b8 <_Watchdog_Insert> <== NOT EXECUTED 10c7ee: 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 ) 10c7f1: 83 7e 34 01 cmpl $0x1,0x34(%esi) <== NOT EXECUTED 10c7f5: 75 9c jne 10c793 <_Thread_queue_Enqueue_with_handler+0x2b> <== NOT EXECUTED 10c7f7: ba 00 c8 10 00 mov $0x10c800,%edx <== NOT EXECUTED 10c7fc: eb 9a jmp 10c798 <_Thread_queue_Enqueue_with_handler+0x30> <== NOT EXECUTED 0010f5e4 <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10f5e4: 55 push %ebp <== NOT EXECUTED 10f5e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f5e7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f5ea: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10f5ed: 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 ) 10f5f0: 83 78 34 01 cmpl $0x1,0x34(%eax) <== NOT EXECUTED 10f5f4: 74 0e je 10f604 <_Thread_queue_Extract+0x20> <== NOT EXECUTED _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 ); 10f5f6: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 10f5f9: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10f5fc: 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 ); 10f5fd: e9 ce 0a 00 00 jmp 1100d0 <_Thread_queue_Extract_fifo> <== NOT EXECUTED 10f602: 66 90 xchg %ax,%ax <== 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 ) _Thread_queue_Extract_priority( the_thread_queue, the_thread ); 10f604: 51 push %ecx <== NOT EXECUTED 10f605: 6a 00 push $0x0 <== NOT EXECUTED 10f607: 52 push %edx <== NOT EXECUTED 10f608: 50 push %eax <== NOT EXECUTED 10f609: e8 06 00 00 00 call 10f614 <_Thread_queue_Extract_priority_helper> <== NOT EXECUTED 10f60e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); } 10f611: c9 leave <== NOT EXECUTED 10f612: c3 ret <== NOT EXECUTED 001100d0 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 1100d0: 55 push %ebp <== NOT EXECUTED 1100d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1100d3: 53 push %ebx <== NOT EXECUTED 1100d4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1100d7: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 1100da: 9c pushf <== NOT EXECUTED 1100db: fa cli <== NOT EXECUTED 1100dc: 59 pop %ecx <== NOT EXECUTED if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 1100dd: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) <== NOT EXECUTED 1100e4: 74 2e je 110114 <_Thread_queue_Extract_fifo+0x44> <== NOT EXECUTED 1100e6: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 1100e8: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 1100eb: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 1100ee: 89 10 mov %edx,(%eax) <== NOT EXECUTED return; } _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; 1100f0: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 1100f7: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 1100fb: 74 1f je 11011c <_Thread_queue_Extract_fifo+0x4c> <== NOT EXECUTED _ISR_Enable( level ); 1100fd: 51 push %ecx <== NOT EXECUTED 1100fe: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 1100ff: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 110106: 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 } 110109: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11010c: c9 leave <== NOT EXECUTED 11010d: e9 ee bd ff ff jmp 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 110112: 66 90 xchg %ax,%ax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _ISR_Enable( level ); 110114: 51 push %ecx <== NOT EXECUTED 110115: 9d popf <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 110116: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110119: c9 leave <== NOT EXECUTED 11011a: c3 ret <== NOT EXECUTED 11011b: 90 nop <== 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 */ 11011c: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 110123: 51 push %ecx <== NOT EXECUTED 110124: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 110125: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110128: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 11012b: 50 push %eax <== NOT EXECUTED 11012c: e8 b7 d1 ff ff call 10d2e8 <_Watchdog_Remove> <== NOT EXECUTED 110131: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110134: eb c9 jmp 1100ff <_Thread_queue_Extract_fifo+0x2f> <== NOT EXECUTED 0010f614 <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, bool requeuing ) { 10f614: 55 push %ebp <== NOT EXECUTED 10f615: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f617: 57 push %edi <== NOT EXECUTED 10f618: 56 push %esi <== NOT EXECUTED 10f619: 53 push %ebx <== NOT EXECUTED 10f61a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f61d: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10f620: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 10f623: 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 ); 10f626: 9c pushf <== NOT EXECUTED 10f627: fa cli <== NOT EXECUTED 10f628: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10f62b: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) <== NOT EXECUTED 10f632: 74 68 je 10f69c <_Thread_queue_Extract_priority_helper+0x88> <== NOT EXECUTED /* * The thread was actually waiting on a thread queue so let's remove it. */ next_node = the_node->next; 10f634: 8b 33 mov (%ebx),%esi <== NOT EXECUTED previous_node = the_node->previous; 10f636: 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( 10f639: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10f63c: 8d 43 3c lea 0x3c(%ebx),%eax <== NOT EXECUTED 10f63f: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10f641: 74 71 je 10f6b4 <_Thread_queue_Extract_priority_helper+0xa0> <== 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; 10f643: 8b 43 40 mov 0x40(%ebx),%eax <== NOT EXECUTED 10f646: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED new_second_node = new_first_node->next; 10f649: 8b 3a mov (%edx),%edi <== NOT EXECUTED previous_node->next = new_first_node; 10f64b: 89 11 mov %edx,(%ecx) <== NOT EXECUTED next_node->previous = new_first_node; 10f64d: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED new_first_node->next = next_node; 10f650: 89 32 mov %esi,(%edx) <== NOT EXECUTED new_first_node->previous = previous_node; 10f652: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10f655: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10f658: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 10f65b: 74 17 je 10f674 <_Thread_queue_Extract_priority_helper+0x60> <== NOT EXECUTED /* > two threads on 2-n */ new_second_node->previous = 10f65d: 8d 42 38 lea 0x38(%edx),%eax <== NOT EXECUTED 10f660: 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; 10f663: 89 7a 38 mov %edi,0x38(%edx) <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 10f666: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10f669: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10f66c: 8d 42 3c lea 0x3c(%edx),%eax <== NOT EXECUTED 10f66f: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10f672: 89 02 mov %eax,(%edx) <== NOT EXECUTED /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 10f674: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) <== NOT EXECUTED 10f678: 75 2e jne 10f6a8 <_Thread_queue_Extract_priority_helper+0x94> <== NOT EXECUTED _ISR_Enable( level ); return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10f67a: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10f67e: 74 3c je 10f6bc <_Thread_queue_Extract_priority_helper+0xa8> <== NOT EXECUTED _ISR_Enable( level ); 10f680: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10f683: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10f684: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 10f68b: 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 } 10f68e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f691: 5b pop %ebx <== NOT EXECUTED 10f692: 5e pop %esi <== NOT EXECUTED 10f693: 5f pop %edi <== NOT EXECUTED 10f694: c9 leave <== NOT EXECUTED 10f695: e9 66 c8 ff ff jmp 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 10f69a: 66 90 xchg %ax,%ax <== NOT EXECUTED Chain_Node *last_node; the_node = (Chain_Node *) the_thread; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _ISR_Enable( level ); 10f69c: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10f69f: 9d popf <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10f6a0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f6a3: 5b pop %ebx <== NOT EXECUTED 10f6a4: 5e pop %esi <== NOT EXECUTED 10f6a5: 5f pop %edi <== NOT EXECUTED 10f6a6: c9 leave <== NOT EXECUTED 10f6a7: c3 ret <== NOT EXECUTED /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { _ISR_Enable( level ); 10f6a8: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10f6ab: 9d popf <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10f6ac: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f6af: 5b pop %ebx <== NOT EXECUTED 10f6b0: 5e pop %esi <== NOT EXECUTED 10f6b1: 5f pop %edi <== NOT EXECUTED 10f6b2: c9 leave <== NOT EXECUTED 10f6b3: c3 ret <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); } } else { previous_node->next = next_node; 10f6b4: 89 31 mov %esi,(%ecx) <== NOT EXECUTED next_node->previous = previous_node; 10f6b6: 89 4e 04 mov %ecx,0x4(%esi) <== NOT EXECUTED 10f6b9: eb b9 jmp 10f674 <_Thread_queue_Extract_priority_helper+0x60> <== NOT EXECUTED 10f6bb: 90 nop <== 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 */ 10f6bc: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10f6c3: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10f6c6: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10f6c7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f6ca: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10f6cd: 50 push %eax <== NOT EXECUTED 10f6ce: e8 15 dc ff ff call 10d2e8 <_Watchdog_Remove> <== NOT EXECUTED 10f6d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f6d6: eb ac jmp 10f684 <_Thread_queue_Extract_priority_helper+0x70> <== NOT EXECUTED 0010c984 <_Thread_queue_Extract_with_proxy>: */ bool _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 10c984: 55 push %ebp <== NOT EXECUTED 10c985: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c987: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c98a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED States_Control state; state = the_thread->current_state; if ( _States_Is_waiting_on_thread_queue( state ) ) { 10c98d: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax) <== NOT EXECUTED 10c994: 75 06 jne 10c99c <_Thread_queue_Extract_with_proxy+0x18> <== NOT EXECUTED 10c996: 31 c0 xor %eax,%eax <== NOT EXECUTED _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); return TRUE; } return FALSE; } 10c998: c9 leave <== NOT EXECUTED 10c999: c3 ret <== NOT EXECUTED 10c99a: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( proxy_extract_callout ) (*proxy_extract_callout)( the_thread ); } #endif _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10c99c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c99f: 50 push %eax <== NOT EXECUTED 10c9a0: ff 70 44 pushl 0x44(%eax) <== NOT EXECUTED 10c9a3: e8 3c 2c 00 00 call 10f5e4 <_Thread_queue_Extract> <== NOT EXECUTED 10c9a8: b0 01 mov $0x1,%al <== NOT EXECUTED 10c9aa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return TRUE; } return FALSE; } 10c9ad: c9 leave <== NOT EXECUTED 10c9ae: c3 ret <== NOT EXECUTED 0011a9e0 <_Thread_queue_First>: */ Thread_Control *_Thread_queue_First( Thread_queue_Control *the_thread_queue ) { 11a9e0: 55 push %ebp <== NOT EXECUTED 11a9e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11a9e3: 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 ) 11a9e6: 83 78 34 01 cmpl $0x1,0x34(%eax) <== NOT EXECUTED 11a9ea: 74 0c je 11a9f8 <_Thread_queue_First+0x18> <== NOT EXECUTED 11a9ec: b9 f8 b3 11 00 mov $0x11b3f8,%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 ); 11a9f1: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 11a9f4: 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 ); 11a9f5: ff e1 jmp *%ecx <== NOT EXECUTED 11a9f7: 90 nop <== NOT EXECUTED Thread_queue_Control *the_thread_queue ) { Thread_Control * (*first_p)(Thread_queue_Control *); if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 11a9f8: b9 04 aa 11 00 mov $0x11aa04,%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 ); 11a9fd: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 11aa00: 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 ); 11aa01: ff e1 jmp *%ecx <== NOT EXECUTED 0011b3f8 <_Thread_queue_First_fifo>: */ Thread_Control *_Thread_queue_First_fifo( Thread_queue_Control *the_thread_queue ) { 11b3f8: 55 push %ebp <== NOT EXECUTED 11b3f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11b3fb: 8b 45 08 mov 0x8(%ebp),%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( 11b3fe: 8b 10 mov (%eax),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) 11b400: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 11b403: 39 c2 cmp %eax,%edx <== NOT EXECUTED 11b405: 74 05 je 11b40c <_Thread_queue_First_fifo+0x14> <== NOT EXECUTED return (Thread_Control *) the_thread_queue->Queues.Fifo.first; 11b407: 89 d0 mov %edx,%eax <== NOT EXECUTED return NULL; } 11b409: c9 leave <== NOT EXECUTED 11b40a: c3 ret <== NOT EXECUTED 11b40b: 90 nop <== NOT EXECUTED Thread_Control *_Thread_queue_First_fifo( Thread_queue_Control *the_thread_queue ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) 11b40c: 31 c0 xor %eax,%eax <== NOT EXECUTED return (Thread_Control *) the_thread_queue->Queues.Fifo.first; return NULL; } 11b40e: c9 leave <== NOT EXECUTED 11b40f: c3 ret <== NOT EXECUTED 0011aa04 <_Thread_queue_First_priority>: */ Thread_Control *_Thread_queue_First_priority ( Thread_queue_Control *the_thread_queue ) { 11aa04: 55 push %ebp <== NOT EXECUTED 11aa05: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11aa07: 56 push %esi <== NOT EXECUTED 11aa08: 53 push %ebx <== NOT EXECUTED 11aa09: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 11aa0c: 31 d2 xor %edx,%edx <== NOT EXECUTED 11aa0e: 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( 11aa10: 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 ] ) ) 11aa13: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 11aa16: 8d 44 86 04 lea 0x4(%esi,%eax,4),%eax <== NOT EXECUTED 11aa1a: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 11aa1c: 75 12 jne 11aa30 <_Thread_queue_First_priority+0x2c> <== NOT EXECUTED { uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 11aa1e: 42 inc %edx <== NOT EXECUTED 11aa1f: 83 c1 0c add $0xc,%ecx <== NOT EXECUTED ) { uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 11aa22: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 11aa25: 75 e9 jne 11aa10 <_Thread_queue_First_priority+0xc> <== NOT EXECUTED 11aa27: 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; } 11aa29: 5b pop %ebx <== NOT EXECUTED 11aa2a: 5e pop %esi <== NOT EXECUTED 11aa2b: c9 leave <== NOT EXECUTED 11aa2c: c3 ret <== NOT EXECUTED 11aa2d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) return (Thread_Control *) 11aa30: 89 d8 mov %ebx,%eax <== NOT EXECUTED the_thread_queue->Queues.Priority[ index ].first; } return NULL; } 11aa32: 5b pop %ebx <== NOT EXECUTED 11aa33: 5e pop %esi <== NOT EXECUTED 11aa34: c9 leave <== NOT EXECUTED 11aa35: c3 ret <== NOT EXECUTED 0010c9b0 <_Thread_queue_Flush>: void _Thread_queue_Flush( Thread_queue_Control *the_thread_queue, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 10c9b0: 55 push %ebp <== NOT EXECUTED 10c9b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c9b3: 56 push %esi <== NOT EXECUTED 10c9b4: 53 push %ebx <== NOT EXECUTED 10c9b5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10c9b8: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10c9bb: eb 06 jmp 10c9c3 <_Thread_queue_Flush+0x13> <== NOT EXECUTED 10c9bd: 8d 76 00 lea 0x0(%esi),%esi <== 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; 10c9c0: 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 )) ) { 10c9c3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c9c6: 56 push %esi <== NOT EXECUTED 10c9c7: e8 60 fc ff ff call 10c62c <_Thread_queue_Dequeue> <== NOT EXECUTED 10c9cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c9cf: 85 c0 test %eax,%eax <== NOT EXECUTED 10c9d1: 75 ed jne 10c9c0 <_Thread_queue_Flush+0x10> <== NOT EXECUTED ( *remote_extract_callout )( the_thread ); else #endif the_thread->Wait.return_code = status; } } 10c9d3: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c9d6: 5b pop %ebx <== NOT EXECUTED 10c9d7: 5e pop %esi <== NOT EXECUTED 10c9d8: c9 leave <== NOT EXECUTED 10c9d9: c3 ret <== NOT EXECUTED 0010c9dc <_Thread_queue_Initialize>: Thread_queue_Control *the_thread_queue, Thread_queue_Disciplines the_discipline, States_Control state, uint32_t timeout_status ) { 10c9dc: 55 push %ebp <== NOT EXECUTED 10c9dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c9df: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c9e2: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED the_thread_queue->state = state; 10c9e5: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10c9e8: 89 51 38 mov %edx,0x38(%ecx) <== NOT EXECUTED the_thread_queue->discipline = the_discipline; 10c9eb: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED the_thread_queue->timeout_status = timeout_status; 10c9ee: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10c9f1: 89 51 3c mov %edx,0x3c(%ecx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c9f4: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) <== NOT EXECUTED if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10c9fb: 48 dec %eax <== NOT EXECUTED 10c9fc: 74 12 je 10ca10 <_Thread_queue_Initialize+0x34> <== NOT EXECUTED 10c9fe: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10ca01: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10ca03: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10ca0a: 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 ); } } 10ca0d: c9 leave <== NOT EXECUTED 10ca0e: c3 ret <== NOT EXECUTED 10ca0f: 90 nop <== NOT EXECUTED 10ca10: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10ca13: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10ca15: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10ca1c: 89 49 08 mov %ecx,0x8(%ecx) <== NOT EXECUTED 10ca1f: 8d 41 10 lea 0x10(%ecx),%eax <== NOT EXECUTED 10ca22: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED 10ca25: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx) <== NOT EXECUTED 10ca2c: 8d 41 0c lea 0xc(%ecx),%eax <== NOT EXECUTED 10ca2f: 89 41 14 mov %eax,0x14(%ecx) <== NOT EXECUTED 10ca32: 8d 41 1c lea 0x1c(%ecx),%eax <== NOT EXECUTED 10ca35: 89 41 18 mov %eax,0x18(%ecx) <== NOT EXECUTED 10ca38: c7 41 1c 00 00 00 00 movl $0x0,0x1c(%ecx) <== NOT EXECUTED 10ca3f: 8d 41 18 lea 0x18(%ecx),%eax <== NOT EXECUTED 10ca42: 89 41 20 mov %eax,0x20(%ecx) <== NOT EXECUTED 10ca45: 8d 41 28 lea 0x28(%ecx),%eax <== NOT EXECUTED 10ca48: 89 41 24 mov %eax,0x24(%ecx) <== NOT EXECUTED 10ca4b: c7 41 28 00 00 00 00 movl $0x0,0x28(%ecx) <== NOT EXECUTED 10ca52: 8d 41 24 lea 0x24(%ecx),%eax <== NOT EXECUTED 10ca55: 89 41 2c mov %eax,0x2c(%ecx) <== NOT EXECUTED 10ca58: c9 leave <== NOT EXECUTED 10ca59: c3 ret <== NOT EXECUTED 0010f6d8 <_Thread_queue_Process_timeout>: #include void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { 10f6d8: 55 push %ebp <== NOT EXECUTED 10f6d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f6db: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f6de: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 10f6e1: 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 && 10f6e4: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10f6e7: 85 c0 test %eax,%eax <== NOT EXECUTED 10f6e9: 74 08 je 10f6f3 <_Thread_queue_Process_timeout+0x1b> <== NOT EXECUTED 10f6eb: 3b 0d bc ea 11 00 cmp 0x11eabc,%ecx <== NOT EXECUTED 10f6f1: 74 19 je 10f70c <_Thread_queue_Process_timeout+0x34> <== NOT EXECUTED if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; } } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10f6f3: 8b 42 3c mov 0x3c(%edx),%eax <== NOT EXECUTED 10f6f6: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10f6f9: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f6fc: 51 push %ecx <== NOT EXECUTED 10f6fd: ff 71 44 pushl 0x44(%ecx) <== NOT EXECUTED 10f700: e8 df fe ff ff call 10f5e4 <_Thread_queue_Extract> <== NOT EXECUTED 10f705: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 10f708: c9 leave <== NOT EXECUTED 10f709: c3 ret <== NOT EXECUTED 10f70a: 66 90 xchg %ax,%ax <== NOT EXECUTED * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED && _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) { 10f70c: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10f70f: 74 f7 je 10f708 <_Thread_queue_Process_timeout+0x30> <== NOT EXECUTED the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10f711: 8b 42 3c mov 0x3c(%edx),%eax <== NOT EXECUTED 10f714: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10f717: c7 42 30 02 00 00 00 movl $0x2,0x30(%edx) <== NOT EXECUTED } } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); } } 10f71e: c9 leave <== NOT EXECUTED 10f71f: c3 ret <== NOT EXECUTED 0010ca5c <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10ca5c: 55 push %ebp <== NOT EXECUTED 10ca5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca5f: 56 push %esi <== NOT EXECUTED 10ca60: 53 push %ebx <== NOT EXECUTED 10ca61: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ca64: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue ) 10ca67: 85 db test %ebx,%ebx <== NOT EXECUTED 10ca69: 74 06 je 10ca71 <_Thread_queue_Requeue+0x15> <== 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 ) { 10ca6b: 83 7b 34 01 cmpl $0x1,0x34(%ebx) <== NOT EXECUTED 10ca6f: 74 07 je 10ca78 <_Thread_queue_Requeue+0x1c> <== NOT EXECUTED _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); } _ISR_Enable( level ); } } 10ca71: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ca74: 5b pop %ebx <== NOT EXECUTED 10ca75: 5e pop %esi <== NOT EXECUTED 10ca76: c9 leave <== NOT EXECUTED 10ca77: c3 ret <== NOT EXECUTED if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 10ca78: 9c pushf <== NOT EXECUTED 10ca79: fa cli <== NOT EXECUTED 10ca7a: 5e pop %esi <== NOT EXECUTED if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10ca7b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ca7e: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax) <== NOT EXECUTED 10ca85: 75 09 jne 10ca90 <_Thread_queue_Requeue+0x34> <== NOT EXECUTED _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); } _ISR_Enable( level ); 10ca87: 56 push %esi <== NOT EXECUTED 10ca88: 9d popf <== NOT EXECUTED } } 10ca89: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ca8c: 5b pop %ebx <== NOT EXECUTED 10ca8d: 5e pop %esi <== NOT EXECUTED 10ca8e: c9 leave <== NOT EXECUTED 10ca8f: 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 10ca90: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) <== NOT EXECUTED ISR_Level level_ignored; _ISR_Disable( level ); if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); 10ca97: 52 push %edx <== NOT EXECUTED 10ca98: 6a 01 push $0x1 <== NOT EXECUTED 10ca9a: 50 push %eax <== NOT EXECUTED 10ca9b: 53 push %ebx <== NOT EXECUTED 10ca9c: e8 73 2b 00 00 call 10f614 <_Thread_queue_Extract_priority_helper> <== NOT EXECUTED (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10caa1: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10caa4: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10caa7: 50 push %eax <== NOT EXECUTED 10caa8: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10caab: 53 push %ebx <== NOT EXECUTED 10caac: e8 4f fd ff ff call 10c800 <_Thread_queue_Enqueue_priority> <== NOT EXECUTED 10cab1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cab4: eb d1 jmp 10ca87 <_Thread_queue_Requeue+0x2b> <== NOT EXECUTED 0010cab8 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 10cab8: 55 push %ebp <== NOT EXECUTED 10cab9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cabb: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10cabe: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10cac1: 50 push %eax <== NOT EXECUTED 10cac2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cac5: e8 02 f8 ff ff call 10c2cc <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10caca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cacd: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10cad0: 85 d2 test %edx,%edx <== NOT EXECUTED 10cad2: 75 17 jne 10caeb <_Thread_queue_Timeout+0x33> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10cad4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cad7: 50 push %eax <== NOT EXECUTED 10cad8: e8 fb 2b 00 00 call 10f6d8 <_Thread_queue_Process_timeout> <== NOT EXECUTED 10cadd: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10cae2: 48 dec %eax <== NOT EXECUTED 10cae3: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED 10cae8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Unnest_dispatch(); break; } } 10caeb: c9 leave <== NOT EXECUTED 10caec: c3 ret <== NOT EXECUTED 0010ecb0 <_Timer_Manager_initialization>: */ void _Timer_Manager_initialization( uint32_t maximum_timers ) { 10ecb0: 55 push %ebp <== NOT EXECUTED 10ecb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ecb3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ecb6: 6a 04 push $0x4 <== NOT EXECUTED 10ecb8: 6a 00 push $0x0 <== NOT EXECUTED 10ecba: 6a 3c push $0x3c <== NOT EXECUTED 10ecbc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ecbf: 6a 02 push $0x2 <== NOT EXECUTED 10ecc1: 6a 02 push $0x2 <== NOT EXECUTED 10ecc3: 68 00 ef 11 00 push $0x11ef00 <== NOT EXECUTED 10ecc8: e8 fb cd ff ff call 10bac8 <_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; 10eccd: c7 05 44 ef 11 00 00 movl $0x0,0x11ef44 <== NOT EXECUTED 10ecd4: 00 00 00 <== NOT EXECUTED _Timer_Server_schedule_operation = NULL; 10ecd7: c7 05 40 ef 11 00 00 movl $0x0,0x11ef40 <== NOT EXECUTED 10ecde: 00 00 00 <== NOT EXECUTED 10ece1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED } 10ece4: c9 leave <== NOT EXECUTED 10ece5: c3 ret <== NOT EXECUTED 00114c5c <_Timer_Server_body>: * @param[in] ignored is the the task argument that is ignored */ Thread _Timer_Server_body( uint32_t ignored ) { 114c5c: 55 push %ebp <== NOT EXECUTED 114c5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114c5f: 57 push %edi <== NOT EXECUTED 114c60: 56 push %esi <== NOT EXECUTED 114c61: 53 push %ebx <== NOT EXECUTED 114c62: 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 114c65: 8d 7d e8 lea -0x18(%ebp),%edi <== NOT EXECUTED 114c68: 8d 75 ec lea -0x14(%ebp),%esi <== NOT EXECUTED 114c6b: 89 75 e8 mov %esi,-0x18(%ebp) <== NOT EXECUTED 114c6e: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) <== NOT EXECUTED 114c75: 89 7d f0 mov %edi,-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; 114c78: a1 64 5c 13 00 mov 0x135c64,%eax <== NOT EXECUTED 114c7d: a3 50 5a 13 00 mov %eax,0x135a50 <== NOT EXECUTED _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 114c82: a1 8c 5b 13 00 mov 0x135b8c,%eax <== NOT EXECUTED 114c87: a3 4c 5a 13 00 mov %eax,0x135a4c <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 114c8c: a1 f8 5a 13 00 mov 0x135af8,%eax <== NOT EXECUTED 114c91: 40 inc %eax <== NOT EXECUTED 114c92: a3 f8 5a 13 00 mov %eax,0x135af8 <== 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(); 114c97: e8 60 ff ff ff call 114bfc <_Timer_Server_process_insertions> <== NOT EXECUTED _Thread_Enable_dispatch(); 114c9c: e8 3f 27 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 114ca1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 114ca4: a1 f8 5a 13 00 mov 0x135af8,%eax <== NOT EXECUTED 114ca9: 40 inc %eax <== NOT EXECUTED 114caa: a3 f8 5a 13 00 mov %eax,0x135af8 <== NOT EXECUTED /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 114caf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114cb2: 6a 08 push $0x8 <== NOT EXECUTED 114cb4: ff 35 a4 5e 13 00 pushl 0x135ea4 <== NOT EXECUTED 114cba: e8 19 31 00 00 call 117dd8 <_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( 114cbf: 8b 15 40 5a 13 00 mov 0x135a40,%edx <== NOT EXECUTED _Timer_Server_reset_ticks_timer(); 114cc5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114cc8: 81 fa 44 5a 13 00 cmp $0x135a44,%edx <== NOT EXECUTED 114cce: 74 1f je 114cef <_Timer_Server_body+0x93> <== NOT EXECUTED 114cd0: a1 a4 5e 13 00 mov 0x135ea4,%eax <== NOT EXECUTED Heap_Control *the_heap, 114cd5: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 114cd8: 89 50 54 mov %edx,0x54(%eax) <== NOT EXECUTED void *starting_address, size_t *size 114cdb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114cde: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 114ce1: 50 push %eax <== NOT EXECUTED 114ce2: 68 dc 5b 13 00 push $0x135bdc <== NOT EXECUTED 114ce7: e8 bc 39 00 00 call 1186a8 <_Watchdog_Insert> <== NOT EXECUTED 114cec: 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( 114cef: a1 54 5a 13 00 mov 0x135a54,%eax <== NOT EXECUTED _Timer_Server_reset_seconds_timer(); 114cf4: 3d 58 5a 13 00 cmp $0x135a58,%eax <== NOT EXECUTED 114cf9: 74 1d je 114d18 <_Timer_Server_body+0xbc> <== 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, 114cfb: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 114cfe: a3 8c 5a 13 00 mov %eax,0x135a8c <== NOT EXECUTED size_t size ); 114d03: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114d06: 68 80 5a 13 00 push $0x135a80 <== NOT EXECUTED 114d0b: 68 d0 5b 13 00 push $0x135bd0 <== NOT EXECUTED 114d10: e8 93 39 00 00 call 1186a8 <_Watchdog_Insert> <== NOT EXECUTED 114d15: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Enable_dispatch(); 114d18: e8 c3 26 00 00 call 1173e0 <_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 114d1d: a1 f8 5a 13 00 mov 0x135af8,%eax <== NOT EXECUTED 114d22: 40 inc %eax <== NOT EXECUTED 114d23: a3 f8 5a 13 00 mov %eax,0x135af8 <== 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(); 114d28: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114d2b: a1 a4 5e 13 00 mov 0x135ea4,%eax <== NOT EXECUTED 114d30: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 114d33: 50 push %eax <== NOT EXECUTED 114d34: e8 9f 3a 00 00 call 1187d8 <_Watchdog_Remove> <== NOT EXECUTED _Timer_Server_stop_seconds_timer(); 114d39: c7 04 24 80 5a 13 00 movl $0x135a80,(%esp) <== NOT EXECUTED 114d40: e8 93 3a 00 00 call 1187d8 <_Watchdog_Remove> <== NOT EXECUTED ) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 114d45: 8b 15 64 5c 13 00 mov 0x135c64,%edx <== NOT EXECUTED if ( snapshot >= _Timer_Server_ticks_last_time ) 114d4b: a1 50 5a 13 00 mov 0x135a50,%eax <== NOT EXECUTED 114d50: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114d53: 39 c2 cmp %eax,%edx <== NOT EXECUTED 114d55: 72 7d jb 114dd4 <_Timer_Server_body+0x178> <== NOT EXECUTED ticks = snapshot - _Timer_Server_ticks_last_time; 114d57: 89 d1 mov %edx,%ecx <== NOT EXECUTED 114d59: 29 c1 sub %eax,%ecx <== NOT EXECUTED 114d5b: 89 c8 mov %ecx,%eax <== NOT EXECUTED else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; _Timer_Server_ticks_last_time = snapshot; 114d5d: 89 15 50 5a 13 00 mov %edx,0x135a50 <== NOT EXECUTED _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire ); 114d63: 53 push %ebx <== NOT EXECUTED 114d64: 57 push %edi <== NOT EXECUTED 114d65: 50 push %eax <== NOT EXECUTED 114d66: 68 40 5a 13 00 push $0x135a40 <== NOT EXECUTED 114d6b: e8 a4 38 00 00 call 118614 <_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; 114d70: 8b 1d 8c 5b 13 00 mov 0x135b8c,%ebx <== NOT EXECUTED if ( snapshot > _Timer_Server_seconds_last_time ) { 114d76: a1 4c 5a 13 00 mov 0x135a4c,%eax <== NOT EXECUTED 114d7b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114d7e: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 114d80: 77 5a ja 114ddc <_Timer_Server_body+0x180> <== NOT EXECUTED * TOD has been set forward. */ ticks = snapshot - _Timer_Server_seconds_last_time; _Watchdog_Adjust_to_chain( &_Timer_Seconds_chain, ticks, to_fire ); } else if ( snapshot < _Timer_Server_seconds_last_time ) { 114d82: 72 70 jb 114df4 <_Timer_Server_body+0x198> <== NOT EXECUTED * TOD has been set backwards. */ ticks = _Timer_Server_seconds_last_time - snapshot; _Watchdog_Adjust( &_Timer_Seconds_chain, WATCHDOG_BACKWARD, ticks ); } _Timer_Server_seconds_last_time = snapshot; 114d84: 89 1d 4c 5a 13 00 mov %ebx,0x135a4c <== NOT EXECUTED _Timer_Server_process_seconds_chain( &to_fire ); /* * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); 114d8a: e8 6d fe ff ff call 114bfc <_Timer_Server_process_insertions> <== NOT EXECUTED /* * Enable dispatching to process the set that are ready "to fire." */ _Thread_Enable_dispatch(); 114d8f: e8 4c 26 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED */ while (1) { Watchdog_Control *watch; ISR_Level level; _ISR_Disable( level ); 114d94: 9c pushf <== NOT EXECUTED 114d95: fa cli <== NOT EXECUTED 114d96: 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( 114d97: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 114d9a: 39 d6 cmp %edx,%esi <== NOT EXECUTED 114d9c: 74 2c je 114dca <_Timer_Server_body+0x16e> <== NOT EXECUTED 114d9e: 66 90 xchg %ax,%ax <== NOT EXECUTED 114da0: 8b 02 mov (%edx),%eax <== NOT EXECUTED 114da2: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 114da5: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED if ( watch == NULL ) { _ISR_Enable( level ); break; } watch->state = WATCHDOG_INACTIVE; 114da8: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) <== NOT EXECUTED _ISR_Enable( level ); 114daf: 51 push %ecx <== NOT EXECUTED 114db0: 9d popf <== NOT EXECUTED (*watch->routine)( watch->id, watch->user_data ); 114db1: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114db4: ff 72 24 pushl 0x24(%edx) <== NOT EXECUTED 114db7: ff 72 20 pushl 0x20(%edx) <== NOT EXECUTED 114dba: ff 52 1c call *0x1c(%edx) <== NOT EXECUTED */ while (1) { Watchdog_Control *watch; ISR_Level level; _ISR_Disable( level ); 114dbd: 9c pushf <== NOT EXECUTED 114dbe: fa cli <== NOT EXECUTED 114dbf: 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( 114dc0: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 114dc3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114dc6: 39 d6 cmp %edx,%esi <== NOT EXECUTED 114dc8: 75 d6 jne 114da0 <_Timer_Server_body+0x144> <== NOT EXECUTED watch = (Watchdog_Control *) _Chain_Get_unprotected( &to_fire ); if ( watch == NULL ) { _ISR_Enable( level ); 114dca: 51 push %ecx <== NOT EXECUTED 114dcb: 9d popf <== NOT EXECUTED 114dcc: e9 d3 fe ff ff jmp 114ca4 <_Timer_Server_body+0x48> <== NOT EXECUTED 114dd1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED snapshot = _Watchdog_Ticks_since_boot; if ( snapshot >= _Timer_Server_ticks_last_time ) ticks = snapshot - _Timer_Server_ticks_last_time; else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; 114dd4: f7 d0 not %eax <== NOT EXECUTED 114dd6: 01 d0 add %edx,%eax <== NOT EXECUTED 114dd8: eb 83 jmp 114d5d <_Timer_Server_body+0x101> <== NOT EXECUTED 114dda: 66 90 xchg %ax,%ax <== 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 ); 114ddc: 51 push %ecx <== NOT EXECUTED 114ddd: 57 push %edi <== NOT EXECUTED 114dde: 89 da mov %ebx,%edx <== NOT EXECUTED 114de0: 29 c2 sub %eax,%edx <== NOT EXECUTED 114de2: 52 push %edx <== NOT EXECUTED 114de3: 68 54 5a 13 00 push $0x135a54 <== NOT EXECUTED 114de8: e8 27 38 00 00 call 118614 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED 114ded: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114df0: eb 92 jmp 114d84 <_Timer_Server_body+0x128> <== NOT EXECUTED 114df2: 66 90 xchg %ax,%ax <== 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 ); 114df4: 52 push %edx <== NOT EXECUTED 114df5: 29 d8 sub %ebx,%eax <== NOT EXECUTED 114df7: 50 push %eax <== NOT EXECUTED 114df8: 6a 01 push $0x1 <== NOT EXECUTED 114dfa: 68 54 5a 13 00 push $0x135a54 <== NOT EXECUTED 114dff: e8 94 37 00 00 call 118598 <_Watchdog_Adjust> <== NOT EXECUTED 114e04: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114e07: e9 78 ff ff ff jmp 114d84 <_Timer_Server_body+0x128> <== NOT EXECUTED 00114bfc <_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) { 114bfc: 55 push %ebp <== NOT EXECUTED 114bfd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114bff: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114c02: eb 0a jmp 114c0e <_Timer_Server_process_insertions+0x12> <== NOT EXECUTED if ( the_timer == NULL ) break; if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); } else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 114c04: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 114c07: 74 37 je 114c40 <_Timer_Server_process_insertions+0x44> <== NOT EXECUTED } /* * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); 114c09: e8 ee ff ff ff call 114bfc <_Timer_Server_process_insertions> <== NOT EXECUTED static void _Timer_Server_process_insertions(void) { Timer_Control *the_timer; while ( 1 ) { the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted ); 114c0e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114c11: 68 60 5a 13 00 push $0x135a60 <== NOT EXECUTED 114c16: e8 69 08 00 00 call 115484 <_Chain_Get> <== NOT EXECUTED if ( the_timer == NULL ) 114c1b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114c1e: 85 c0 test %eax,%eax <== NOT EXECUTED 114c20: 74 36 je 114c58 <_Timer_Server_process_insertions+0x5c> <== NOT EXECUTED break; if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { 114c22: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 114c25: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 114c28: 75 da jne 114c04 <_Timer_Server_process_insertions+0x8> <== NOT EXECUTED _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 114c2a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114c2d: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 114c30: 50 push %eax <== NOT EXECUTED 114c31: 68 40 5a 13 00 push $0x135a40 <== NOT EXECUTED 114c36: e8 6d 3a 00 00 call 1186a8 <_Watchdog_Insert> <== NOT EXECUTED 114c3b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114c3e: eb c9 jmp 114c09 <_Timer_Server_process_insertions+0xd> <== NOT EXECUTED } else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { _Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker ); 114c40: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114c43: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 114c46: 50 push %eax <== NOT EXECUTED 114c47: 68 54 5a 13 00 push $0x135a54 <== NOT EXECUTED 114c4c: e8 57 3a 00 00 call 1186a8 <_Watchdog_Insert> <== NOT EXECUTED 114c51: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114c54: eb b3 jmp 114c09 <_Timer_Server_process_insertions+0xd> <== NOT EXECUTED 114c56: 66 90 xchg %ax,%ax <== NOT EXECUTED * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); } } 114c58: c9 leave <== NOT EXECUTED 114c59: c3 ret <== NOT EXECUTED 00114bc0 <_Timer_Server_schedule_operation_method>: * the directive invoking this is executed. */ static void _Timer_Server_schedule_operation_method( Timer_Control *the_timer ) { 114bc0: 55 push %ebp <== NOT EXECUTED 114bc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114bc3: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED _Chain_Append( &_Timer_To_be_inserted, &the_timer->Object.Node ); 114bc6: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114bc9: 68 60 5a 13 00 push $0x135a60 <== NOT EXECUTED 114bce: e8 8d 08 00 00 call 115460 <_Chain_Append> <== NOT EXECUTED _Watchdog_Remove( &_Timer_Server->Timer ); 114bd3: a1 a4 5e 13 00 mov 0x135ea4,%eax <== NOT EXECUTED 114bd8: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 114bdb: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 114bde: e8 f5 3b 00 00 call 1187d8 <_Watchdog_Remove> <== NOT EXECUTED _Thread_Delay_ended( _Timer_Server->Object.id, NULL ); 114be3: 5a pop %edx <== NOT EXECUTED 114be4: 59 pop %ecx <== NOT EXECUTED 114be5: 6a 00 push $0x0 <== NOT EXECUTED 114be7: a1 a4 5e 13 00 mov 0x135ea4,%eax <== NOT EXECUTED 114bec: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 114bef: e8 54 26 00 00 call 117248 <_Thread_Delay_ended> <== NOT EXECUTED 114bf4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 114bf7: c9 leave <== NOT EXECUTED 114bf8: c3 ret <== NOT EXECUTED 0010ced8 <_Timespec_Add_to>: uint32_t _Timespec_Add_to( struct timespec *time, const struct timespec *add ) { 10ced8: 55 push %ebp <== NOT EXECUTED 10ced9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cedb: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10cede: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED uint32_t seconds = add->tv_sec; 10cee1: 8b 08 mov (%eax),%ecx <== NOT EXECUTED /* Add the basics */ time->tv_sec += add->tv_sec; 10cee3: 01 0a add %ecx,(%edx) <== NOT EXECUTED time->tv_nsec += add->tv_nsec; 10cee5: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10cee8: 03 42 04 add 0x4(%edx),%eax <== NOT EXECUTED 10ceeb: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 10ceee: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 10cef3: 76 15 jbe 10cf0a <_Timespec_Add_to+0x32> <== NOT EXECUTED 10cef5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 10cef8: 2d 00 ca 9a 3b sub $0x3b9aca00,%eax <== NOT EXECUTED 10cefd: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED time->tv_sec++; 10cf00: ff 02 incl (%edx) <== NOT EXECUTED seconds++; 10cf02: 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 ) { 10cf03: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 10cf08: 77 ee ja 10cef8 <_Timespec_Add_to+0x20> <== NOT EXECUTED time->tv_sec++; seconds++; } return seconds; } 10cf0a: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10cf0c: c9 leave <== NOT EXECUTED 10cf0d: c3 ret <== NOT EXECUTED 0010e594 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 10e594: 55 push %ebp <== NOT EXECUTED 10e595: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e597: 57 push %edi <== NOT EXECUTED 10e598: 56 push %esi <== NOT EXECUTED 10e599: 53 push %ebx <== NOT EXECUTED 10e59a: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 10e59d: 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; 10e5a0: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10e5a2: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED left += lhs->tv_nsec; 10e5a5: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10e5a8: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10e5ab: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx <== NOT EXECUTED 10e5b0: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10e5b3: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10e5b5: f7 e9 imul %ecx <== NOT EXECUTED 10e5b7: 89 c6 mov %eax,%esi <== NOT EXECUTED 10e5b9: 89 d7 mov %edx,%edi <== NOT EXECUTED right += rhs->tv_nsec; 10e5bb: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10e5be: 99 cltd <== NOT EXECUTED 10e5bf: 01 c6 add %eax,%esi <== NOT EXECUTED 10e5c1: 11 d7 adc %edx,%edi <== NOT EXECUTED if ( right == 0 ) { 10e5c3: 89 f8 mov %edi,%eax <== NOT EXECUTED 10e5c5: 09 f0 or %esi,%eax <== NOT EXECUTED 10e5c7: 74 77 je 10e640 <_Timespec_Divide+0xac> <== 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; 10e5c9: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10e5cc: f7 e9 imul %ecx <== NOT EXECUTED 10e5ce: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10e5d1: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 10e5d4: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 10e5d7: 99 cltd <== NOT EXECUTED 10e5d8: 01 45 e0 add %eax,-0x20(%ebp) <== NOT EXECUTED 10e5db: 11 55 e4 adc %edx,-0x1c(%ebp) <== NOT EXECUTED 10e5de: 69 5d e4 a0 86 01 00 imul $0x186a0,-0x1c(%ebp),%ebx <== NOT EXECUTED 10e5e5: b9 a0 86 01 00 mov $0x186a0,%ecx <== NOT EXECUTED 10e5ea: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10e5ed: f7 e1 mul %ecx <== NOT EXECUTED 10e5ef: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 10e5f2: 01 da add %ebx,%edx <== NOT EXECUTED 10e5f4: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED 10e5f7: 57 push %edi <== NOT EXECUTED 10e5f8: 56 push %esi <== NOT EXECUTED 10e5f9: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 10e5fc: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED 10e5ff: e8 94 a8 00 00 call 118e98 <__udivdi3> <== NOT EXECUTED 10e604: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e607: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10e609: 89 d6 mov %edx,%esi <== NOT EXECUTED *ival_percentage = answer / 1000; 10e60b: 6a 00 push $0x0 <== NOT EXECUTED 10e60d: 68 e8 03 00 00 push $0x3e8 <== NOT EXECUTED 10e612: 52 push %edx <== NOT EXECUTED 10e613: 50 push %eax <== NOT EXECUTED 10e614: e8 7f a8 00 00 call 118e98 <__udivdi3> <== NOT EXECUTED 10e619: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e61c: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10e61f: 89 01 mov %eax,(%ecx) <== NOT EXECUTED *fval_percentage = answer % 1000; 10e621: 6a 00 push $0x0 <== NOT EXECUTED 10e623: 68 e8 03 00 00 push $0x3e8 <== NOT EXECUTED 10e628: 56 push %esi <== NOT EXECUTED 10e629: 53 push %ebx <== NOT EXECUTED 10e62a: e8 75 a9 00 00 call 118fa4 <__umoddi3> <== NOT EXECUTED 10e62f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e632: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 10e635: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } 10e637: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e63a: 5b pop %ebx <== NOT EXECUTED 10e63b: 5e pop %esi <== NOT EXECUTED 10e63c: 5f pop %edi <== NOT EXECUTED 10e63d: c9 leave <== NOT EXECUTED 10e63e: c3 ret <== NOT EXECUTED 10e63f: 90 nop <== NOT EXECUTED left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; right += rhs->tv_nsec; if ( right == 0 ) { *ival_percentage = 0; 10e640: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10e643: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED *fval_percentage = 0; 10e649: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10e64c: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED answer = (left * 100000) / right; *ival_percentage = answer / 1000; *fval_percentage = answer % 1000; } 10e652: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e655: 5b pop %ebx <== NOT EXECUTED 10e656: 5e pop %esi <== NOT EXECUTED 10e657: 5f pop %edi <== NOT EXECUTED 10e658: c9 leave <== NOT EXECUTED 10e659: c3 ret <== NOT EXECUTED 00127030 <_Timespec_Divide_by_integer>: void _Timespec_Divide_by_integer( const struct timespec *time, uint32_t iterations, struct timespec *result ) { 127030: 55 push %ebp <== NOT EXECUTED 127031: 89 e5 mov %esp,%ebp <== NOT EXECUTED 127033: 57 push %edi <== NOT EXECUTED 127034: 56 push %esi <== NOT EXECUTED 127035: 53 push %ebx <== NOT EXECUTED 127036: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 127039: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 12703c: 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; 12703f: 8b 06 mov (%esi),%eax <== NOT EXECUTED 127041: 99 cltd <== NOT EXECUTED t *= TOD_NANOSECONDS_PER_SECOND; 127042: 69 da 00 ca 9a 3b imul $0x3b9aca00,%edx,%ebx <== NOT EXECUTED 127048: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx <== NOT EXECUTED 12704d: f7 e1 mul %ecx <== NOT EXECUTED 12704f: 8d 14 13 lea (%ebx,%edx,1),%edx <== NOT EXECUTED t += time->tv_nsec; 127052: 8b 4e 04 mov 0x4(%esi),%ecx <== NOT EXECUTED 127055: 89 cb mov %ecx,%ebx <== NOT EXECUTED 127057: c1 fb 1f sar $0x1f,%ebx <== NOT EXECUTED 12705a: 01 c8 add %ecx,%eax <== NOT EXECUTED 12705c: 11 da adc %ebx,%edx <== NOT EXECUTED /* * Divide to get nanoseconds per iteration */ t /= iterations; 12705e: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 127061: 31 db xor %ebx,%ebx <== NOT EXECUTED 127063: 53 push %ebx <== NOT EXECUTED 127064: 51 push %ecx <== NOT EXECUTED 127065: 52 push %edx <== NOT EXECUTED 127066: 50 push %eax <== NOT EXECUTED 127067: e8 b0 7b 01 00 call 13ec1c <__udivdi3> <== NOT EXECUTED 12706c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12706f: 89 c3 mov %eax,%ebx <== NOT EXECUTED 127071: 89 d6 mov %edx,%esi <== NOT EXECUTED /* * Put it back in the timespec result */ result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND; 127073: 6a 00 push $0x0 <== NOT EXECUTED 127075: 68 00 ca 9a 3b push $0x3b9aca00 <== NOT EXECUTED 12707a: 52 push %edx <== NOT EXECUTED 12707b: 50 push %eax <== NOT EXECUTED 12707c: e8 9b 7b 01 00 call 13ec1c <__udivdi3> <== NOT EXECUTED 127081: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 127084: 89 07 mov %eax,(%edi) <== NOT EXECUTED result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND; 127086: 6a 00 push $0x0 <== NOT EXECUTED 127088: 68 00 ca 9a 3b push $0x3b9aca00 <== NOT EXECUTED 12708d: 56 push %esi <== NOT EXECUTED 12708e: 53 push %ebx <== NOT EXECUTED 12708f: e8 94 7c 01 00 call 13ed28 <__umoddi3> <== NOT EXECUTED 127094: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 127097: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED } 12709a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12709d: 5b pop %ebx <== NOT EXECUTED 12709e: 5e pop %esi <== NOT EXECUTED 12709f: 5f pop %edi <== NOT EXECUTED 1270a0: c9 leave <== NOT EXECUTED 1270a1: c3 ret <== NOT EXECUTED 00116900 <_Timespec_From_ticks>: void _Timespec_From_ticks( uint32_t ticks, struct timespec *time ) { 116900: 55 push %ebp <== NOT EXECUTED 116901: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116903: 53 push %ebx <== NOT EXECUTED 116904: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 116907: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED uint32_t usecs; usecs = ticks * _TOD_Microseconds_per_tick; 11690a: 0f af 1d a0 cb 12 00 imul 0x12cba0,%ebx <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 116911: ba 83 de 1b 43 mov $0x431bde83,%edx <== NOT EXECUTED 116916: 89 d8 mov %ebx,%eax <== NOT EXECUTED 116918: f7 e2 mul %edx <== NOT EXECUTED 11691a: c1 ea 12 shr $0x12,%edx <== NOT EXECUTED 11691d: 89 11 mov %edx,(%ecx) <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 11691f: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 116922: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 116925: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 116928: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 11692b: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 11692e: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 116931: c1 e2 06 shl $0x6,%edx <== NOT EXECUTED 116934: 29 d3 sub %edx,%ebx <== NOT EXECUTED 116936: 8d 04 9b lea (%ebx,%ebx,4),%eax <== NOT EXECUTED 116939: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 11693c: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 11693f: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED 116942: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED TOD_NANOSECONDS_PER_MICROSECOND; } 116945: 5b pop %ebx <== NOT EXECUTED 116946: c9 leave <== NOT EXECUTED 116947: c3 ret <== NOT EXECUTED 0010e9c4 <_Timespec_Greater_than>: bool _Timespec_Greater_than( const struct timespec *lhs, const struct timespec *rhs ) { 10e9c4: 55 push %ebp <== NOT EXECUTED 10e9c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e9c7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10e9ca: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED if ( lhs->tv_sec > rhs->tv_sec ) 10e9cd: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10e9cf: 39 02 cmp %eax,(%edx) <== NOT EXECUTED 10e9d1: 7f 11 jg 10e9e4 <_Timespec_Greater_than+0x20> <== NOT EXECUTED return TRUE; if ( lhs->tv_sec < rhs->tv_sec ) 10e9d3: 7c 0b jl 10e9e0 <_Timespec_Greater_than+0x1c> <== NOT EXECUTED return FALSE; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec > rhs->tv_nsec ) 10e9d5: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10e9d8: 3b 41 04 cmp 0x4(%ecx),%eax <== NOT EXECUTED 10e9db: 0f 9f c0 setg %al <== NOT EXECUTED return TRUE; return FALSE; } 10e9de: c9 leave <== NOT EXECUTED 10e9df: c3 ret <== NOT EXECUTED ) { if ( lhs->tv_sec > rhs->tv_sec ) return TRUE; if ( lhs->tv_sec < rhs->tv_sec ) 10e9e0: 31 c0 xor %eax,%eax <== NOT EXECUTED /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec > rhs->tv_nsec ) return TRUE; return FALSE; } 10e9e2: c9 leave <== NOT EXECUTED 10e9e3: c3 ret <== NOT EXECUTED bool _Timespec_Greater_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec > rhs->tv_sec ) 10e9e4: b0 01 mov $0x1,%al <== NOT EXECUTED /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec > rhs->tv_nsec ) return TRUE; return FALSE; } 10e9e6: c9 leave <== NOT EXECUTED 10e9e7: c3 ret <== NOT EXECUTED 00116948 <_Timespec_Is_valid>: #include bool _Timespec_Is_valid( const struct timespec *time ) { 116948: 55 push %ebp <== NOT EXECUTED 116949: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11694b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !time ) 11694e: 85 c0 test %eax,%eax <== NOT EXECUTED 116950: 74 1a je 11696c <_Timespec_Is_valid+0x24> <== NOT EXECUTED return FALSE; if ( time->tv_sec < 0 ) 116952: 8b 10 mov (%eax),%edx <== NOT EXECUTED 116954: 85 d2 test %edx,%edx <== NOT EXECUTED 116956: 78 14 js 11696c <_Timespec_Is_valid+0x24> <== NOT EXECUTED return FALSE; if ( time->tv_nsec < 0 ) 116958: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 11695b: 85 c0 test %eax,%eax <== NOT EXECUTED 11695d: 78 0d js 11696c <_Timespec_Is_valid+0x24> <== NOT EXECUTED 11695f: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 116964: 0f 96 c0 setbe %al <== NOT EXECUTED if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return FALSE; return TRUE; } 116967: c9 leave <== NOT EXECUTED 116968: c3 ret <== NOT EXECUTED 116969: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return FALSE; if ( time->tv_sec < 0 ) return FALSE; if ( time->tv_nsec < 0 ) 11696c: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return FALSE; return TRUE; } 11696e: c9 leave <== NOT EXECUTED 11696f: c3 ret <== NOT EXECUTED 0010e9e8 <_Timespec_Less_than>: bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { 10e9e8: 55 push %ebp <== NOT EXECUTED 10e9e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e9eb: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10e9ee: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED if ( lhs->tv_sec < rhs->tv_sec ) 10e9f1: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10e9f3: 39 02 cmp %eax,(%edx) <== NOT EXECUTED 10e9f5: 7c 11 jl 10ea08 <_Timespec_Less_than+0x20> <== NOT EXECUTED return TRUE; if ( lhs->tv_sec > rhs->tv_sec ) 10e9f7: 7f 0b jg 10ea04 <_Timespec_Less_than+0x1c> <== NOT EXECUTED return FALSE; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) 10e9f9: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10e9fc: 3b 41 04 cmp 0x4(%ecx),%eax <== NOT EXECUTED 10e9ff: 0f 9c c0 setl %al <== NOT EXECUTED return TRUE; return FALSE; } 10ea02: c9 leave <== NOT EXECUTED 10ea03: c3 ret <== NOT EXECUTED ) { if ( lhs->tv_sec < rhs->tv_sec ) return TRUE; if ( lhs->tv_sec > rhs->tv_sec ) 10ea04: 31 c0 xor %eax,%eax <== NOT EXECUTED /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) return TRUE; return FALSE; } 10ea06: c9 leave <== NOT EXECUTED 10ea07: c3 ret <== NOT EXECUTED bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec < rhs->tv_sec ) 10ea08: b0 01 mov $0x1,%al <== NOT EXECUTED /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) return TRUE; return FALSE; } 10ea0a: c9 leave <== NOT EXECUTED 10ea0b: c3 ret <== NOT EXECUTED 0010cf10 <_Timespec_Subtract>: void _Timespec_Subtract( const struct timespec *start, const struct timespec *end, struct timespec *result ) { 10cf10: 55 push %ebp <== NOT EXECUTED 10cf11: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cf13: 53 push %ebx <== NOT EXECUTED 10cf14: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10cf17: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10cf1a: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED if (end->tv_nsec < start->tv_nsec) { 10cf1d: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 10cf20: 3b 51 04 cmp 0x4(%ecx),%edx <== NOT EXECUTED 10cf23: 7c 0f jl 10cf34 <_Timespec_Subtract+0x24> <== NOT EXECUTED result->tv_sec = end->tv_sec - start->tv_sec - 1; result->tv_nsec = (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec; } else { result->tv_sec = end->tv_sec - start->tv_sec; 10cf25: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10cf27: 2b 01 sub (%ecx),%eax <== NOT EXECUTED 10cf29: 89 03 mov %eax,(%ebx) <== NOT EXECUTED result->tv_nsec = end->tv_nsec - start->tv_nsec; 10cf2b: 2b 51 04 sub 0x4(%ecx),%edx <== NOT EXECUTED 10cf2e: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED } } 10cf31: 5b pop %ebx <== NOT EXECUTED 10cf32: c9 leave <== NOT EXECUTED 10cf33: c3 ret <== NOT EXECUTED struct timespec *result ) { if (end->tv_nsec < start->tv_nsec) { result->tv_sec = end->tv_sec - start->tv_sec - 1; 10cf34: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10cf36: 48 dec %eax <== NOT EXECUTED 10cf37: 2b 01 sub (%ecx),%eax <== NOT EXECUTED 10cf39: 89 03 mov %eax,(%ebx) <== NOT EXECUTED result->tv_nsec = 10cf3b: 8d 82 00 ca 9a 3b lea 0x3b9aca00(%edx),%eax <== NOT EXECUTED 10cf41: 2b 41 04 sub 0x4(%ecx),%eax <== NOT EXECUTED 10cf44: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec; } else { result->tv_sec = end->tv_sec - start->tv_sec; result->tv_nsec = end->tv_nsec - start->tv_nsec; } } 10cf47: 5b pop %ebx <== NOT EXECUTED 10cf48: c9 leave <== NOT EXECUTED 10cf49: c3 ret <== NOT EXECUTED 00116970 <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 116970: 55 push %ebp <== NOT EXECUTED 116971: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116973: 57 push %edi <== NOT EXECUTED 116974: 56 push %esi <== NOT EXECUTED 116975: 53 push %ebx <== NOT EXECUTED 116976: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 116979: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 11697c: 8b 30 mov (%eax),%esi <== NOT EXECUTED 11697e: 85 f6 test %esi,%esi <== NOT EXECUTED 116980: 74 3e je 1169c0 <_Timespec_To_ticks+0x50> <== NOT EXECUTED 116982: 8b 58 04 mov 0x4(%eax),%ebx <== NOT EXECUTED return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 116985: 8b 0d a0 cb 12 00 mov 0x12cba0,%ecx <== NOT EXECUTED 11698b: bf 40 42 0f 00 mov $0xf4240,%edi <== NOT EXECUTED 116990: 89 f8 mov %edi,%eax <== NOT EXECUTED 116992: 31 d2 xor %edx,%edx <== NOT EXECUTED 116994: f7 f1 div %ecx <== NOT EXECUTED 116996: 89 c7 mov %eax,%edi <== NOT EXECUTED 116998: 0f af fe imul %esi,%edi <== NOT EXECUTED ticks += (time->tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND) / 11699b: be d3 4d 62 10 mov $0x10624dd3,%esi <== NOT EXECUTED 1169a0: 89 f0 mov %esi,%eax <== NOT EXECUTED 1169a2: f7 e3 mul %ebx <== NOT EXECUTED 1169a4: 89 d3 mov %edx,%ebx <== NOT EXECUTED 1169a6: c1 eb 06 shr $0x6,%ebx <== NOT EXECUTED 1169a9: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1169ab: 31 d2 xor %edx,%edx <== NOT EXECUTED 1169ad: f7 f1 div %ecx <== NOT EXECUTED _TOD_Microseconds_per_tick; if (ticks) 1169af: 01 f8 add %edi,%eax <== NOT EXECUTED 1169b1: 75 05 jne 1169b8 <_Timespec_To_ticks+0x48> <== NOT EXECUTED 1169b3: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED return ticks; return 1; } 1169b8: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 1169bb: 5b pop %ebx <== NOT EXECUTED 1169bc: 5e pop %esi <== NOT EXECUTED 1169bd: 5f pop %edi <== NOT EXECUTED 1169be: c9 leave <== NOT EXECUTED 1169bf: c3 ret <== NOT EXECUTED const struct timespec *time ) { uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 1169c0: 8b 58 04 mov 0x4(%eax),%ebx <== NOT EXECUTED 1169c3: 85 db test %ebx,%ebx <== NOT EXECUTED 1169c5: 75 be jne 116985 <_Timespec_To_ticks+0x15> <== NOT EXECUTED 1169c7: 31 c0 xor %eax,%eax <== NOT EXECUTED if (ticks) return ticks; return 1; } 1169c9: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 1169cc: 5b pop %ebx <== NOT EXECUTED 1169cd: 5e pop %esi <== NOT EXECUTED 1169ce: 5f pop %edi <== NOT EXECUTED 1169cf: c9 leave <== NOT EXECUTED 1169d0: c3 ret <== NOT EXECUTED 0010f824 <_User_extensions_Add_API_set>: */ void _User_extensions_Add_API_set ( User_extensions_Control *the_extension ) { 10f824: 55 push %ebp <== NOT EXECUTED 10f825: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f827: 53 push %ebx <== NOT EXECUTED 10f828: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f82b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED _Chain_Append( &_User_extensions_List, &the_extension->Node ); 10f82e: 53 push %ebx <== NOT EXECUTED 10f82f: 68 4c ec 11 00 push $0x11ec4c <== NOT EXECUTED 10f834: e8 ff b4 ff ff call 10ad38 <_Chain_Append> <== NOT EXECUTED /* * If a switch handler is present, append it to the switch chain. */ if ( the_extension->Callouts.thread_switch != NULL ) { 10f839: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 10f83c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f83f: 85 c0 test %eax,%eax <== NOT EXECUTED 10f841: 74 17 je 10f85a <_User_extensions_Add_API_set+0x36> <== NOT EXECUTED the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch; 10f843: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _Chain_Append( 10f846: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f849: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10f84c: 50 push %eax <== NOT EXECUTED 10f84d: 68 fc e9 11 00 push $0x11e9fc <== NOT EXECUTED 10f852: e8 e1 b4 ff ff call 10ad38 <_Chain_Append> <== NOT EXECUTED 10f857: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10f85a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f85d: c9 leave <== NOT EXECUTED 10f85e: c3 ret <== NOT EXECUTED 0010f860 <_User_extensions_Add_set>: void _User_extensions_Add_set ( User_extensions_Control *the_extension, User_extensions_Table *extension_table ) { 10f860: 55 push %ebp <== NOT EXECUTED 10f861: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f863: 57 push %edi <== NOT EXECUTED 10f864: 56 push %esi <== NOT EXECUTED 10f865: 53 push %ebx <== NOT EXECUTED 10f866: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10f869: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10f86c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f86f: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED the_extension->Callouts = *extension_table; 10f872: 8d 7b 14 lea 0x14(%ebx),%edi <== NOT EXECUTED 10f875: b9 08 00 00 00 mov $0x8,%ecx <== NOT EXECUTED 10f87a: 89 c6 mov %eax,%esi <== NOT EXECUTED 10f87c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED _Chain_Append( &_User_extensions_List, &the_extension->Node ); 10f87e: 53 push %ebx <== NOT EXECUTED 10f87f: 68 4c ec 11 00 push $0x11ec4c <== NOT EXECUTED 10f884: e8 af b4 ff ff call 10ad38 <_Chain_Append> <== NOT EXECUTED /* * If a switch handler is present, append it to the switch chain. */ if ( extension_table->thread_switch != NULL ) { 10f889: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10f88c: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10f88f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f892: 85 c0 test %eax,%eax <== NOT EXECUTED 10f894: 74 1e je 10f8b4 <_User_extensions_Add_set+0x54> <== NOT EXECUTED the_extension->Switch.thread_switch = extension_table->thread_switch; 10f896: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _Chain_Append( 10f899: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10f89c: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10f89f: c7 45 08 fc e9 11 00 movl $0x11e9fc,0x8(%ebp) <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10f8a6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f8a9: 5b pop %ebx <== NOT EXECUTED 10f8aa: 5e pop %esi <== NOT EXECUTED 10f8ab: 5f pop %edi <== NOT EXECUTED 10f8ac: 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( 10f8ad: e9 86 b4 ff ff jmp 10ad38 <_Chain_Append> <== NOT EXECUTED 10f8b2: 66 90 xchg %ax,%ax <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10f8b4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f8b7: 5b pop %ebx <== NOT EXECUTED 10f8b8: 5e pop %esi <== NOT EXECUTED 10f8b9: 5f pop %edi <== NOT EXECUTED 10f8ba: c9 leave <== NOT EXECUTED 10f8bb: c3 ret <== NOT EXECUTED 0010d068 <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) { 10d068: 55 push %ebp <== NOT EXECUTED 10d069: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d06b: 57 push %edi <== NOT EXECUTED 10d06c: 56 push %esi <== NOT EXECUTED 10d06d: 53 push %ebx <== NOT EXECUTED 10d06e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d071: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10d074: 8a 45 0c mov 0xc(%ebp),%al <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10d077: 8b 1d 54 ec 11 00 mov 0x11ec54,%ebx <== NOT EXECUTED !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10d07d: 81 fb 4c ec 11 00 cmp $0x11ec4c,%ebx <== NOT EXECUTED 10d083: 74 20 je 10d0a5 <_User_extensions_Fatal+0x3d> <== 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 ); 10d085: 0f b6 f0 movzbl %al,%esi <== 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 ) 10d088: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10d08b: 85 c0 test %eax,%eax <== NOT EXECUTED 10d08d: 74 0b je 10d09a <_User_extensions_Fatal+0x32> <== NOT EXECUTED (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10d08f: 52 push %edx <== NOT EXECUTED 10d090: 57 push %edi <== NOT EXECUTED 10d091: 56 push %esi <== NOT EXECUTED 10d092: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d095: ff d0 call *%eax <== NOT EXECUTED 10d097: 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 ) { 10d09a: 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 ) ; 10d09d: 81 fb 4c ec 11 00 cmp $0x11ec4c,%ebx <== NOT EXECUTED 10d0a3: 75 e3 jne 10d088 <_User_extensions_Fatal+0x20> <== 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 ); } } 10d0a5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d0a8: 5b pop %ebx <== NOT EXECUTED 10d0a9: 5e pop %esi <== NOT EXECUTED 10d0aa: 5f pop %edi <== NOT EXECUTED 10d0ab: c9 leave <== NOT EXECUTED 10d0ac: c3 ret <== NOT EXECUTED 0010cf4c <_User_extensions_Handler_initialization>: void _User_extensions_Handler_initialization ( uint32_t number_of_extensions, User_extensions_Table *initial_extensions ) { 10cf4c: 55 push %ebp <== NOT EXECUTED 10cf4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cf4f: 57 push %edi <== NOT EXECUTED 10cf50: 56 push %esi <== NOT EXECUTED 10cf51: 53 push %ebx <== NOT EXECUTED 10cf52: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cf55: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10cf58: c7 05 4c ec 11 00 50 movl $0x11ec50,0x11ec4c <== NOT EXECUTED 10cf5f: ec 11 00 <== NOT EXECUTED 10cf62: c7 05 50 ec 11 00 00 movl $0x0,0x11ec50 <== NOT EXECUTED 10cf69: 00 00 00 <== NOT EXECUTED 10cf6c: c7 05 54 ec 11 00 4c movl $0x11ec4c,0x11ec54 <== NOT EXECUTED 10cf73: ec 11 00 <== NOT EXECUTED 10cf76: c7 05 fc e9 11 00 00 movl $0x11ea00,0x11e9fc <== NOT EXECUTED 10cf7d: ea 11 00 <== NOT EXECUTED 10cf80: c7 05 00 ea 11 00 00 movl $0x0,0x11ea00 <== NOT EXECUTED 10cf87: 00 00 00 <== NOT EXECUTED 10cf8a: c7 05 04 ea 11 00 fc movl $0x11e9fc,0x11ea04 <== NOT EXECUTED 10cf91: e9 11 00 <== NOT EXECUTED uint32_t i; _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10cf94: 85 f6 test %esi,%esi <== NOT EXECUTED 10cf96: 74 50 je 10cfe8 <_User_extensions_Handler_initialization+0x9c> <== NOT EXECUTED extension = (User_extensions_Control *) 10cf98: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10cf9b: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10cf9e: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 10cfa1: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 10cfa8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cfab: 53 push %ebx <== NOT EXECUTED 10cfac: e8 43 04 00 00 call 10d3f4 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10cfb1: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10cfb4: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cfb6: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 10cfb9: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 10cfbb: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10cfbd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cfc0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cfc3: 85 c0 test %eax,%eax <== NOT EXECUTED 10cfc5: 74 21 je 10cfe8 <_User_extensions_Handler_initialization+0x9c> <== NOT EXECUTED 10cfc7: 31 db xor %ebx,%ebx <== NOT EXECUTED 10cfc9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _User_extensions_Add_set (extension, &initial_extensions[i]); 10cfcc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10cfcf: 56 push %esi <== NOT EXECUTED 10cfd0: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10cfd3: e8 88 28 00 00 call 10f860 <_User_extensions_Add_set> <== NOT EXECUTED extension++; 10cfd8: 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++ ) { 10cfdc: 43 inc %ebx <== NOT EXECUTED 10cfdd: 83 c6 20 add $0x20,%esi <== NOT EXECUTED 10cfe0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cfe3: 39 5d 08 cmp %ebx,0x8(%ebp) <== NOT EXECUTED 10cfe6: 77 e4 ja 10cfcc <_User_extensions_Handler_initialization+0x80> <== NOT EXECUTED _User_extensions_Add_set (extension, &initial_extensions[i]); extension++; } } } 10cfe8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cfeb: 5b pop %ebx <== NOT EXECUTED 10cfec: 5e pop %esi <== NOT EXECUTED 10cfed: 5f pop %edi <== NOT EXECUTED 10cfee: c9 leave <== NOT EXECUTED 10cfef: c3 ret <== NOT EXECUTED 00111e84 <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 111e84: 55 push %ebp <== NOT EXECUTED 111e85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111e87: 53 push %ebx <== NOT EXECUTED 111e88: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 111e8b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED _Chain_Extract( &the_extension->Node ); 111e8e: 53 push %ebx <== NOT EXECUTED 111e8f: e8 f4 3e 00 00 call 115d88 <_Chain_Extract> <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 111e94: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111e97: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 111e9a: 85 c0 test %eax,%eax <== NOT EXECUTED 111e9c: 74 12 je 111eb0 <_User_extensions_Remove_set+0x2c> <== NOT EXECUTED _Chain_Extract( &the_extension->Switch.Node ); 111e9e: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 111ea1: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 111ea4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111ea7: 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 ); 111ea8: e9 db 3e 00 00 jmp 115d88 <_Chain_Extract> <== NOT EXECUTED 111ead: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } 111eb0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111eb3: c9 leave <== NOT EXECUTED 111eb4: c3 ret <== NOT EXECUTED 0010cff0 <_User_extensions_Thread_begin>: */ void _User_extensions_Thread_begin ( Thread_Control *executing ) { 10cff0: 55 push %ebp <== NOT EXECUTED 10cff1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cff3: 56 push %esi <== NOT EXECUTED 10cff4: 53 push %ebx <== NOT EXECUTED 10cff5: 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 ; 10cff8: 8b 1d 4c ec 11 00 mov 0x11ec4c,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10cffe: 81 fb 50 ec 11 00 cmp $0x11ec50,%ebx <== NOT EXECUTED 10d004: 74 1c je 10d022 <_User_extensions_Thread_begin+0x32> <== NOT EXECUTED 10d006: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_begin != NULL ) 10d008: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 10d00b: 85 c0 test %eax,%eax <== NOT EXECUTED 10d00d: 74 09 je 10d018 <_User_extensions_Thread_begin+0x28> <== NOT EXECUTED (*the_extension->Callouts.thread_begin)( executing ); 10d00f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d012: 56 push %esi <== NOT EXECUTED 10d013: ff d0 call *%eax <== NOT EXECUTED 10d015: 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 ) { 10d018: 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 ) ; 10d01a: 81 fb 50 ec 11 00 cmp $0x11ec50,%ebx <== NOT EXECUTED 10d020: 75 e6 jne 10d008 <_User_extensions_Thread_begin+0x18> <== NOT EXECUTED the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_begin != NULL ) (*the_extension->Callouts.thread_begin)( executing ); } } 10d022: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d025: 5b pop %ebx <== NOT EXECUTED 10d026: 5e pop %esi <== NOT EXECUTED 10d027: c9 leave <== NOT EXECUTED 10d028: c3 ret <== NOT EXECUTED 0010d0b0 <_User_extensions_Thread_create>: */ bool _User_extensions_Thread_create ( Thread_Control *the_thread ) { 10d0b0: 55 push %ebp <== NOT EXECUTED 10d0b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d0b3: 56 push %esi <== NOT EXECUTED 10d0b4: 53 push %ebx <== NOT EXECUTED 10d0b5: 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 ; 10d0b8: 8b 1d 4c ec 11 00 mov 0x11ec4c,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10d0be: 81 fb 50 ec 11 00 cmp $0x11ec50,%ebx <== NOT EXECUTED 10d0c4: 74 26 je 10d0ec <_User_extensions_Thread_create+0x3c> <== NOT EXECUTED 10d0c6: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_create != NULL ) { 10d0c8: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10d0cb: 85 c0 test %eax,%eax <== NOT EXECUTED 10d0cd: 74 13 je 10d0e2 <_User_extensions_Thread_create+0x32> <== NOT EXECUTED status = (*the_extension->Callouts.thread_create)( 10d0cf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d0d2: 56 push %esi <== NOT EXECUTED 10d0d3: ff 35 bc ea 11 00 pushl 0x11eabc <== NOT EXECUTED 10d0d9: ff d0 call *%eax <== NOT EXECUTED _Thread_Executing, the_thread ); if ( !status ) 10d0db: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d0de: 84 c0 test %al,%al <== NOT EXECUTED 10d0e0: 74 0c je 10d0ee <_User_extensions_Thread_create+0x3e> <== 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 ) { 10d0e2: 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 ) ; 10d0e4: 81 fb 50 ec 11 00 cmp $0x11ec50,%ebx <== NOT EXECUTED 10d0ea: 75 dc jne 10d0c8 <_User_extensions_Thread_create+0x18> <== NOT EXECUTED 10d0ec: b0 01 mov $0x1,%al <== NOT EXECUTED return FALSE; } } return TRUE; } 10d0ee: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d0f1: 5b pop %ebx <== NOT EXECUTED 10d0f2: 5e pop %esi <== NOT EXECUTED 10d0f3: c9 leave <== NOT EXECUTED 10d0f4: c3 ret <== NOT EXECUTED 0010d0f8 <_User_extensions_Thread_delete>: */ void _User_extensions_Thread_delete ( Thread_Control *the_thread ) { 10d0f8: 55 push %ebp <== NOT EXECUTED 10d0f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d0fb: 56 push %esi <== NOT EXECUTED 10d0fc: 53 push %ebx <== NOT EXECUTED 10d0fd: 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 ; 10d100: 8b 1d 54 ec 11 00 mov 0x11ec54,%ebx <== NOT EXECUTED !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10d106: 81 fb 4c ec 11 00 cmp $0x11ec4c,%ebx <== NOT EXECUTED 10d10c: 74 23 je 10d131 <_User_extensions_Thread_delete+0x39> <== NOT EXECUTED 10d10e: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_delete != NULL ) 10d110: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 10d113: 85 c0 test %eax,%eax <== NOT EXECUTED 10d115: 74 0f je 10d126 <_User_extensions_Thread_delete+0x2e> <== NOT EXECUTED (*the_extension->Callouts.thread_delete)( 10d117: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d11a: 56 push %esi <== NOT EXECUTED 10d11b: ff 35 bc ea 11 00 pushl 0x11eabc <== NOT EXECUTED 10d121: ff d0 call *%eax <== NOT EXECUTED 10d123: 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 ) { 10d126: 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 ) ; 10d129: 81 fb 4c ec 11 00 cmp $0x11ec4c,%ebx <== NOT EXECUTED 10d12f: 75 df jne 10d110 <_User_extensions_Thread_delete+0x18> <== NOT EXECUTED (*the_extension->Callouts.thread_delete)( _Thread_Executing, the_thread ); } } 10d131: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d134: 5b pop %ebx <== NOT EXECUTED 10d135: 5e pop %esi <== NOT EXECUTED 10d136: c9 leave <== NOT EXECUTED 10d137: c3 ret <== NOT EXECUTED 0010d02c <_User_extensions_Thread_exitted>: */ void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 10d02c: 55 push %ebp <== NOT EXECUTED 10d02d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d02f: 56 push %esi <== NOT EXECUTED 10d030: 53 push %ebx <== NOT EXECUTED 10d031: 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 ; 10d034: 8b 1d 54 ec 11 00 mov 0x11ec54,%ebx <== NOT EXECUTED !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10d03a: 81 fb 4c ec 11 00 cmp $0x11ec4c,%ebx <== NOT EXECUTED 10d040: 74 1d je 10d05f <_User_extensions_Thread_exitted+0x33> <== NOT EXECUTED 10d042: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) 10d044: 8b 43 2c mov 0x2c(%ebx),%eax <== NOT EXECUTED 10d047: 85 c0 test %eax,%eax <== NOT EXECUTED 10d049: 74 09 je 10d054 <_User_extensions_Thread_exitted+0x28> <== NOT EXECUTED (*the_extension->Callouts.thread_exitted)( executing ); 10d04b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d04e: 56 push %esi <== NOT EXECUTED 10d04f: ff d0 call *%eax <== NOT EXECUTED 10d051: 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 ) { 10d054: 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 ) ; 10d057: 81 fb 4c ec 11 00 cmp $0x11ec4c,%ebx <== NOT EXECUTED 10d05d: 75 e5 jne 10d044 <_User_extensions_Thread_exitted+0x18> <== NOT EXECUTED the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) (*the_extension->Callouts.thread_exitted)( executing ); } } 10d05f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d062: 5b pop %ebx <== NOT EXECUTED 10d063: 5e pop %esi <== NOT EXECUTED 10d064: c9 leave <== NOT EXECUTED 10d065: c3 ret <== NOT EXECUTED 0010dc04 <_User_extensions_Thread_restart>: */ void _User_extensions_Thread_restart ( Thread_Control *the_thread ) { 10dc04: 55 push %ebp <== NOT EXECUTED 10dc05: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc07: 56 push %esi <== NOT EXECUTED 10dc08: 53 push %ebx <== NOT EXECUTED 10dc09: 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 ; 10dc0c: 8b 1d 0c 19 12 00 mov 0x12190c,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10dc12: 81 fb 10 19 12 00 cmp $0x121910,%ebx <== NOT EXECUTED 10dc18: 74 22 je 10dc3c <_User_extensions_Thread_restart+0x38> <== NOT EXECUTED 10dc1a: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_restart != NULL ) 10dc1c: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10dc1f: 85 c0 test %eax,%eax <== NOT EXECUTED 10dc21: 74 0f je 10dc32 <_User_extensions_Thread_restart+0x2e> <== NOT EXECUTED (*the_extension->Callouts.thread_restart)( 10dc23: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dc26: 56 push %esi <== NOT EXECUTED 10dc27: ff 35 7c 17 12 00 pushl 0x12177c <== NOT EXECUTED 10dc2d: ff d0 call *%eax <== NOT EXECUTED 10dc2f: 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 ) { 10dc32: 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 ) ; 10dc34: 81 fb 10 19 12 00 cmp $0x121910,%ebx <== NOT EXECUTED 10dc3a: 75 e0 jne 10dc1c <_User_extensions_Thread_restart+0x18> <== NOT EXECUTED (*the_extension->Callouts.thread_restart)( _Thread_Executing, the_thread ); } } 10dc3c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10dc3f: 5b pop %ebx <== NOT EXECUTED 10dc40: 5e pop %esi <== NOT EXECUTED 10dc41: c9 leave <== NOT EXECUTED 10dc42: c3 ret <== NOT EXECUTED 0010d138 <_User_extensions_Thread_start>: */ void _User_extensions_Thread_start ( Thread_Control *the_thread ) { 10d138: 55 push %ebp <== NOT EXECUTED 10d139: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d13b: 56 push %esi <== NOT EXECUTED 10d13c: 53 push %ebx <== NOT EXECUTED 10d13d: 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 ; 10d140: 8b 1d 4c ec 11 00 mov 0x11ec4c,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10d146: 81 fb 50 ec 11 00 cmp $0x11ec50,%ebx <== NOT EXECUTED 10d14c: 74 22 je 10d170 <_User_extensions_Thread_start+0x38> <== NOT EXECUTED 10d14e: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_start != NULL ) 10d150: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10d153: 85 c0 test %eax,%eax <== NOT EXECUTED 10d155: 74 0f je 10d166 <_User_extensions_Thread_start+0x2e> <== NOT EXECUTED (*the_extension->Callouts.thread_start)( 10d157: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d15a: 56 push %esi <== NOT EXECUTED 10d15b: ff 35 bc ea 11 00 pushl 0x11eabc <== NOT EXECUTED 10d161: ff d0 call *%eax <== NOT EXECUTED 10d163: 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 ) { 10d166: 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 ) ; 10d168: 81 fb 50 ec 11 00 cmp $0x11ec50,%ebx <== NOT EXECUTED 10d16e: 75 e0 jne 10d150 <_User_extensions_Thread_start+0x18> <== NOT EXECUTED (*the_extension->Callouts.thread_start)( _Thread_Executing, the_thread ); } } 10d170: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d173: 5b pop %ebx <== NOT EXECUTED 10d174: 5e pop %esi <== NOT EXECUTED 10d175: c9 leave <== NOT EXECUTED 10d176: c3 ret <== NOT EXECUTED 0010d178 <_User_extensions_Thread_switch>: */ void _User_extensions_Thread_switch ( Thread_Control *executing, Thread_Control *heir ) { 10d178: 55 push %ebp <== NOT EXECUTED 10d179: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d17b: 57 push %edi <== NOT EXECUTED 10d17c: 56 push %esi <== NOT EXECUTED 10d17d: 53 push %ebx <== NOT EXECUTED 10d17e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d181: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10d184: 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 ; 10d187: 8b 1d fc e9 11 00 mov 0x11e9fc,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; 10d18d: 81 fb 00 ea 11 00 cmp $0x11ea00,%ebx <== NOT EXECUTED 10d193: 74 18 je 10d1ad <_User_extensions_Thread_switch+0x35> <== NOT EXECUTED 10d195: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_node = the_node->next ) { the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); 10d198: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d19b: 56 push %esi <== NOT EXECUTED 10d19c: 57 push %edi <== NOT EXECUTED 10d19d: 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 ) { 10d1a0: 8b 1b mov (%ebx),%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 ) ; 10d1a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d1a5: 81 fb 00 ea 11 00 cmp $0x11ea00,%ebx <== NOT EXECUTED 10d1ab: 75 eb jne 10d198 <_User_extensions_Thread_switch+0x20> <== NOT EXECUTED the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); } } 10d1ad: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d1b0: 5b pop %ebx <== NOT EXECUTED 10d1b1: 5e pop %esi <== NOT EXECUTED 10d1b2: 5f pop %edi <== NOT EXECUTED 10d1b3: c9 leave <== NOT EXECUTED 10d1b4: c3 ret <== NOT EXECUTED 0010e960 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10e960: 55 push %ebp <== NOT EXECUTED 10e961: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e963: 57 push %edi <== NOT EXECUTED 10e964: 56 push %esi <== NOT EXECUTED 10e965: 53 push %ebx <== NOT EXECUTED 10e966: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e969: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10e96c: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10e96f: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10e972: 9c pushf <== NOT EXECUTED 10e973: fa cli <== NOT EXECUTED 10e974: 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( 10e975: 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 10e977: 8d 5f 04 lea 0x4(%edi),%ebx <== NOT EXECUTED 10e97a: 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 ) ) { 10e97d: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10e97f: 74 3f je 10e9c0 <_Watchdog_Adjust+0x60> <== NOT EXECUTED switch ( direction ) { 10e981: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10e983: 75 47 jne 10e9cc <_Watchdog_Adjust+0x6c> <== NOT EXECUTED case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10e985: 85 f6 test %esi,%esi <== NOT EXECUTED 10e987: 74 37 je 10e9c0 <_Watchdog_Adjust+0x60> <== NOT EXECUTED if ( units < _Watchdog_First( header )->delta_interval ) { 10e989: 8b 58 10 mov 0x10(%eax),%ebx <== NOT EXECUTED 10e98c: 39 de cmp %ebx,%esi <== NOT EXECUTED 10e98e: 73 0f jae 10e99f <_Watchdog_Adjust+0x3f> <== NOT EXECUTED 10e990: eb 42 jmp 10e9d4 <_Watchdog_Adjust+0x74> <== NOT EXECUTED 10e992: 66 90 xchg %ax,%ax <== NOT EXECUTED switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10e994: 29 de sub %ebx,%esi <== NOT EXECUTED 10e996: 74 28 je 10e9c0 <_Watchdog_Adjust+0x60> <== NOT EXECUTED if ( units < _Watchdog_First( header )->delta_interval ) { 10e998: 8b 58 10 mov 0x10(%eax),%ebx <== NOT EXECUTED 10e99b: 39 f3 cmp %esi,%ebx <== NOT EXECUTED 10e99d: 77 35 ja 10e9d4 <_Watchdog_Adjust+0x74> <== NOT EXECUTED _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 10e99f: c7 40 10 01 00 00 00 movl $0x1,0x10(%eax) <== NOT EXECUTED _ISR_Enable( level ); 10e9a6: 52 push %edx <== NOT EXECUTED 10e9a7: 9d popf <== NOT EXECUTED _Watchdog_Tickle( header ); 10e9a8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e9ab: 57 push %edi <== NOT EXECUTED 10e9ac: e8 c7 01 00 00 call 10eb78 <_Watchdog_Tickle> <== NOT EXECUTED _ISR_Disable( level ); 10e9b1: 9c pushf <== NOT EXECUTED 10e9b2: fa cli <== NOT EXECUTED 10e9b3: 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( 10e9b4: 8b 07 mov (%edi),%eax <== NOT EXECUTED if ( _Chain_Is_empty( header ) ) 10e9b6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e9b9: 39 45 f0 cmp %eax,-0x10(%ebp) <== NOT EXECUTED 10e9bc: 75 d6 jne 10e994 <_Watchdog_Adjust+0x34> <== NOT EXECUTED 10e9be: 66 90 xchg %ax,%ax <== NOT EXECUTED } break; } } _ISR_Enable( level ); 10e9c0: 52 push %edx <== NOT EXECUTED 10e9c1: 9d popf <== NOT EXECUTED } 10e9c2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e9c5: 5b pop %ebx <== NOT EXECUTED 10e9c6: 5e pop %esi <== NOT EXECUTED 10e9c7: 5f pop %edi <== NOT EXECUTED 10e9c8: c9 leave <== NOT EXECUTED 10e9c9: c3 ret <== NOT EXECUTED 10e9ca: 66 90 xchg %ax,%ax <== NOT EXECUTED * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { switch ( direction ) { 10e9cc: 49 dec %ecx <== NOT EXECUTED 10e9cd: 75 f1 jne 10e9c0 <_Watchdog_Adjust+0x60> <== NOT EXECUTED case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10e9cf: 01 70 10 add %esi,0x10(%eax) <== NOT EXECUTED 10e9d2: eb ec jmp 10e9c0 <_Watchdog_Adjust+0x60> <== NOT EXECUTED break; case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; 10e9d4: 29 f3 sub %esi,%ebx <== NOT EXECUTED 10e9d6: 89 58 10 mov %ebx,0x10(%eax) <== NOT EXECUTED 10e9d9: eb e5 jmp 10e9c0 <_Watchdog_Adjust+0x60> <== NOT EXECUTED 00118614 <_Watchdog_Adjust_to_chain>: Chain_Control *header, Watchdog_Interval units_arg, Chain_Control *to_fire ) { 118614: 55 push %ebp <== NOT EXECUTED 118615: 89 e5 mov %esp,%ebp <== NOT EXECUTED 118617: 57 push %edi <== NOT EXECUTED 118618: 56 push %esi <== NOT EXECUTED 118619: 53 push %ebx <== NOT EXECUTED 11861a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11861d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 118620: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED Watchdog_Interval units = units_arg; ISR_Level level; Chain_Node *node; if ( !units ) { 118623: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 118626: 85 c0 test %eax,%eax <== NOT EXECUTED 118628: 74 6a je 118694 <_Watchdog_Adjust_to_chain+0x80> <== NOT EXECUTED return; } _ISR_Disable( level ); 11862a: 9c pushf <== NOT EXECUTED 11862b: fa cli <== NOT EXECUTED 11862c: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED 11862f: 8b 13 mov (%ebx),%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 118631: 8d 4b 04 lea 0x4(%ebx),%ecx <== NOT EXECUTED if ( !_Chain_Is_empty( header ) ) { 118634: 39 ca cmp %ecx,%edx <== NOT EXECUTED 118636: 74 58 je 118690 <_Watchdog_Adjust_to_chain+0x7c> <== NOT EXECUTED 118638: 8b 72 10 mov 0x10(%edx),%esi <== NOT EXECUTED 11863b: 8d 47 04 lea 0x4(%edi),%eax <== NOT EXECUTED 11863e: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 118641: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 118644: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 118647: 90 nop <== NOT EXECUTED while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 118648: 3b 75 e8 cmp -0x18(%ebp),%esi <== NOT EXECUTED 11864b: 77 3c ja 118689 <_Watchdog_Adjust_to_chain+0x75> <== NOT EXECUTED _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 0; 11864d: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED 118654: eb 2b jmp 118681 <_Watchdog_Adjust_to_chain+0x6d> <== NOT EXECUTED 118656: 66 90 xchg %ax,%ax <== NOT EXECUTED 118658: 8b 02 mov (%edx),%eax <== NOT EXECUTED 11865a: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 11865c: 89 58 04 mov %ebx,0x4(%eax) <== NOT EXECUTED 11865f: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 118662: 89 02 mov %eax,(%edx) <== NOT EXECUTED 118664: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED 118667: 89 57 08 mov %edx,0x8(%edi) <== NOT EXECUTED 11866a: 89 10 mov %edx,(%eax) <== NOT EXECUTED 11866c: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED do { node = _Chain_Get_unprotected( header ); _Chain_Append_unprotected( to_fire, node ); _ISR_Flash( level ); 11866f: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 118672: 9d popf <== NOT EXECUTED 118673: 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( 118674: 8b 13 mov (%ebx),%edx <== NOT EXECUTED } while ( !_Chain_Is_empty( header ) && _Watchdog_First( header )->delta_interval == 0 ); 118676: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 118678: 74 16 je 118690 <_Watchdog_Adjust_to_chain+0x7c> <== NOT EXECUTED 11867a: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 11867d: 85 c0 test %eax,%eax <== NOT EXECUTED 11867f: 75 1b jne 11869c <_Watchdog_Adjust_to_chain+0x88> <== NOT EXECUTED 118681: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 118683: 75 d3 jne 118658 <_Watchdog_Adjust_to_chain+0x44> <== NOT EXECUTED 118685: 31 d2 xor %edx,%edx <== NOT EXECUTED 118687: eb d6 jmp 11865f <_Watchdog_Adjust_to_chain+0x4b> <== NOT EXECUTED _ISR_Disable( level ); if ( !_Chain_Is_empty( header ) ) { while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; 118689: 2b 75 e8 sub -0x18(%ebp),%esi <== NOT EXECUTED 11868c: 89 72 10 mov %esi,0x10(%edx) <== NOT EXECUTED 11868f: 90 nop <== NOT EXECUTED break; } } } _ISR_Enable( level ); 118690: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 118693: 9d popf <== NOT EXECUTED } 118694: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 118697: 5b pop %ebx <== NOT EXECUTED 118698: 5e pop %esi <== NOT EXECUTED 118699: 5f pop %edi <== NOT EXECUTED 11869a: c9 leave <== NOT EXECUTED 11869b: c3 ret <== NOT EXECUTED return; } _ISR_Disable( level ); if ( !_Chain_Is_empty( header ) ) { while ( units ) { 11869c: 29 75 e8 sub %esi,-0x18(%ebp) <== NOT EXECUTED 11869f: 74 ef je 118690 <_Watchdog_Adjust_to_chain+0x7c> <== NOT EXECUTED 1186a1: 89 c6 mov %eax,%esi <== NOT EXECUTED 1186a3: eb a3 jmp 118648 <_Watchdog_Adjust_to_chain+0x34> <== NOT EXECUTED 0010d288 <_Watchdog_Handler_initialization>: * * Output parameters: NONE */ void _Watchdog_Handler_initialization( void ) { 10d288: 55 push %ebp <== NOT EXECUTED 10d289: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Watchdog_Sync_count = 0; 10d28b: c7 05 60 eb 11 00 00 movl $0x0,0x11eb60 <== NOT EXECUTED 10d292: 00 00 00 <== NOT EXECUTED _Watchdog_Sync_level = 0; 10d295: c7 05 b8 ea 11 00 00 movl $0x0,0x11eab8 <== NOT EXECUTED 10d29c: 00 00 00 <== NOT EXECUTED _Watchdog_Ticks_since_boot = 0; 10d29f: c7 05 64 eb 11 00 00 movl $0x0,0x11eb64 <== NOT EXECUTED 10d2a6: 00 00 00 <== NOT EXECUTED 10d2a9: c7 05 dc ea 11 00 e0 movl $0x11eae0,0x11eadc <== NOT EXECUTED 10d2b0: ea 11 00 <== NOT EXECUTED 10d2b3: c7 05 e0 ea 11 00 00 movl $0x0,0x11eae0 <== NOT EXECUTED 10d2ba: 00 00 00 <== NOT EXECUTED 10d2bd: c7 05 e4 ea 11 00 dc movl $0x11eadc,0x11eae4 <== NOT EXECUTED 10d2c4: ea 11 00 <== NOT EXECUTED 10d2c7: c7 05 d0 ea 11 00 d4 movl $0x11ead4,0x11ead0 <== NOT EXECUTED 10d2ce: ea 11 00 <== NOT EXECUTED 10d2d1: c7 05 d4 ea 11 00 00 movl $0x0,0x11ead4 <== NOT EXECUTED 10d2d8: 00 00 00 <== NOT EXECUTED 10d2db: c7 05 d8 ea 11 00 d0 movl $0x11ead0,0x11ead8 <== NOT EXECUTED 10d2e2: ea 11 00 <== NOT EXECUTED _Chain_Initialize_empty( &_Watchdog_Ticks_chain ); _Chain_Initialize_empty( &_Watchdog_Seconds_chain ); } 10d2e5: c9 leave <== NOT EXECUTED 10d2e6: c3 ret <== NOT EXECUTED 0010d1b8 <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 10d1b8: 55 push %ebp <== NOT EXECUTED 10d1b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d1bb: 57 push %edi <== NOT EXECUTED 10d1bc: 56 push %esi <== NOT EXECUTED 10d1bd: 53 push %ebx <== NOT EXECUTED 10d1be: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d1c1: 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; 10d1c4: 8b 3d 98 ea 11 00 mov 0x11ea98,%edi <== NOT EXECUTED _ISR_Disable( level ); 10d1ca: 9c pushf <== NOT EXECUTED 10d1cb: fa cli <== NOT EXECUTED 10d1cc: 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 ) { 10d1cf: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10d1d2: 85 c0 test %eax,%eax <== NOT EXECUTED 10d1d4: 75 72 jne 10d248 <_Watchdog_Insert+0x90> <== NOT EXECUTED _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 10d1d6: c7 46 08 01 00 00 00 movl $0x1,0x8(%esi) <== NOT EXECUTED _Watchdog_Sync_count++; 10d1dd: a1 60 eb 11 00 mov 0x11eb60,%eax <== NOT EXECUTED 10d1e2: 40 inc %eax <== NOT EXECUTED 10d1e3: a3 60 eb 11 00 mov %eax,0x11eb60 <== NOT EXECUTED restart: delta_interval = the_watchdog->initial; 10d1e8: 8b 5e 0c mov 0xc(%esi),%ebx <== NOT EXECUTED * cache *header!! * * Till Straumann, 7/2003 (gcc-3.2.2 -O4 on powerpc) * */ for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ; 10d1eb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d1ee: 8b 08 mov (%eax),%ecx <== NOT EXECUTED ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10d1f0: 85 db test %ebx,%ebx <== NOT EXECUTED 10d1f2: 74 65 je 10d259 <_Watchdog_Insert+0xa1> <== NOT EXECUTED 10d1f4: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10d1f6: 85 c0 test %eax,%eax <== NOT EXECUTED 10d1f8: 74 5f je 10d259 <_Watchdog_Insert+0xa1> <== NOT EXECUTED break; if ( delta_interval < after->delta_interval ) { 10d1fa: 8b 51 10 mov 0x10(%ecx),%edx <== NOT EXECUTED 10d1fd: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 10d1ff: 73 21 jae 10d222 <_Watchdog_Insert+0x6a> <== NOT EXECUTED 10d201: eb 51 jmp 10d254 <_Watchdog_Insert+0x9c> <== NOT EXECUTED 10d203: 90 nop <== NOT EXECUTED if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 10d204: a1 b8 ea 11 00 mov 0x11eab8,%eax <== NOT EXECUTED 10d209: 39 c7 cmp %eax,%edi <== NOT EXECUTED 10d20b: 72 6f jb 10d27c <_Watchdog_Insert+0xc4> <== NOT EXECUTED if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; break; } delta_interval -= after->delta_interval; 10d20d: 29 d3 sub %edx,%ebx <== NOT EXECUTED ); #ifdef __cplusplus } #endif 10d20f: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED */ for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ; ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10d211: 85 db test %ebx,%ebx <== NOT EXECUTED 10d213: 74 44 je 10d259 <_Watchdog_Insert+0xa1> <== NOT EXECUTED 10d215: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10d217: 85 d2 test %edx,%edx <== NOT EXECUTED 10d219: 74 3e je 10d259 <_Watchdog_Insert+0xa1> <== NOT EXECUTED break; if ( delta_interval < after->delta_interval ) { 10d21b: 8b 51 10 mov 0x10(%ecx),%edx <== NOT EXECUTED 10d21e: 39 da cmp %ebx,%edx <== NOT EXECUTED 10d220: 77 32 ja 10d254 <_Watchdog_Insert+0x9c> <== 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 ); 10d222: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10d225: 9d popf <== NOT EXECUTED 10d226: fa cli <== NOT EXECUTED if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 10d227: 83 7e 08 01 cmpl $0x1,0x8(%esi) <== NOT EXECUTED 10d22b: 74 d7 je 10d204 <_Watchdog_Insert+0x4c> <== NOT EXECUTED _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 10d22d: 89 3d b8 ea 11 00 mov %edi,0x11eab8 <== NOT EXECUTED _Watchdog_Sync_count--; 10d233: a1 60 eb 11 00 mov 0x11eb60,%eax <== NOT EXECUTED 10d238: 48 dec %eax <== NOT EXECUTED 10d239: a3 60 eb 11 00 mov %eax,0x11eb60 <== NOT EXECUTED _ISR_Enable( level ); 10d23e: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10d241: 9d popf <== NOT EXECUTED } 10d242: 58 pop %eax <== NOT EXECUTED 10d243: 5b pop %ebx <== NOT EXECUTED 10d244: 5e pop %esi <== NOT EXECUTED 10d245: 5f pop %edi <== NOT EXECUTED 10d246: c9 leave <== NOT EXECUTED 10d247: c3 ret <== 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 ) { _ISR_Enable( level ); 10d248: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10d24b: 9d popf <== NOT EXECUTED exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; _Watchdog_Sync_count--; _ISR_Enable( level ); } 10d24c: 58 pop %eax <== NOT EXECUTED 10d24d: 5b pop %ebx <== NOT EXECUTED 10d24e: 5e pop %esi <== NOT EXECUTED 10d24f: 5f pop %edi <== NOT EXECUTED 10d250: c9 leave <== NOT EXECUTED 10d251: c3 ret <== NOT EXECUTED 10d252: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( delta_interval == 0 || !_Watchdog_Next( after ) ) break; if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; 10d254: 29 da sub %ebx,%edx <== NOT EXECUTED 10d256: 89 51 10 mov %edx,0x10(%ecx) <== 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( 10d259: c7 46 08 02 00 00 00 movl $0x2,0x8(%esi) <== NOT EXECUTED } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 10d260: 89 5e 10 mov %ebx,0x10(%esi) <== NOT EXECUTED _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 10d263: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d266: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 10d269: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10d26b: 89 30 mov %esi,(%eax) <== NOT EXECUTED 10d26d: 89 16 mov %edx,(%esi) <== NOT EXECUTED 10d26f: 89 72 04 mov %esi,0x4(%edx) <== NOT EXECUTED the_watchdog->start_time = _Watchdog_Ticks_since_boot; 10d272: a1 64 eb 11 00 mov 0x11eb64,%eax <== NOT EXECUTED 10d277: 89 46 14 mov %eax,0x14(%esi) <== NOT EXECUTED 10d27a: eb b1 jmp 10d22d <_Watchdog_Insert+0x75> <== NOT EXECUTED if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { _Watchdog_Sync_level = insert_isr_nest_level; 10d27c: 89 3d b8 ea 11 00 mov %edi,0x11eab8 <== NOT EXECUTED 10d282: e9 61 ff ff ff jmp 10d1e8 <_Watchdog_Insert+0x30> <== NOT EXECUTED 0010d2e8 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10d2e8: 55 push %ebp <== NOT EXECUTED 10d2e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d2eb: 56 push %esi <== NOT EXECUTED 10d2ec: 53 push %ebx <== NOT EXECUTED 10d2ed: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10d2f0: 9c pushf <== NOT EXECUTED 10d2f1: fa cli <== NOT EXECUTED 10d2f2: 5e pop %esi <== NOT EXECUTED previous_state = the_watchdog->state; 10d2f3: 8b 59 08 mov 0x8(%ecx),%ebx <== NOT EXECUTED switch ( previous_state ) { 10d2f6: 83 fb 01 cmp $0x1,%ebx <== NOT EXECUTED 10d2f9: 74 4d je 10d348 <_Watchdog_Remove+0x60> <== NOT EXECUTED 10d2fb: 73 13 jae 10d310 <_Watchdog_Remove+0x28> <== NOT EXECUTED _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10d2fd: a1 64 eb 11 00 mov 0x11eb64,%eax <== NOT EXECUTED 10d302: 89 41 18 mov %eax,0x18(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10d305: 56 push %esi <== NOT EXECUTED 10d306: 9d popf <== NOT EXECUTED return( previous_state ); } 10d307: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10d309: 5b pop %ebx <== NOT EXECUTED 10d30a: 5e pop %esi <== NOT EXECUTED 10d30b: c9 leave <== NOT EXECUTED 10d30c: c3 ret <== NOT EXECUTED 10d30d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); previous_state = the_watchdog->state; switch ( previous_state ) { 10d310: 83 fb 03 cmp $0x3,%ebx <== NOT EXECUTED 10d313: 77 e8 ja 10d2fd <_Watchdog_Remove+0x15> <== NOT EXECUTED break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10d315: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED ); #ifdef __cplusplus } #endif 10d31c: 8b 11 mov (%ecx),%edx <== NOT EXECUTED next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 10d31e: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10d320: 85 c0 test %eax,%eax <== NOT EXECUTED 10d322: 74 06 je 10d32a <_Watchdog_Remove+0x42> <== NOT EXECUTED next_watchdog->delta_interval += the_watchdog->delta_interval; 10d324: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED 10d327: 01 42 10 add %eax,0x10(%edx) <== NOT EXECUTED if ( _Watchdog_Sync_count ) 10d32a: a1 60 eb 11 00 mov 0x11eb60,%eax <== NOT EXECUTED 10d32f: 85 c0 test %eax,%eax <== NOT EXECUTED 10d331: 74 0a je 10d33d <_Watchdog_Remove+0x55> <== NOT EXECUTED _Watchdog_Sync_level = _ISR_Nest_level; 10d333: a1 98 ea 11 00 mov 0x11ea98,%eax <== NOT EXECUTED 10d338: a3 b8 ea 11 00 mov %eax,0x11eab8 <== NOT EXECUTED 10d33d: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d340: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10d343: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10d345: eb b6 jmp 10d2fd <_Watchdog_Remove+0x15> <== NOT EXECUTED 10d347: 90 nop <== 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; 10d348: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED 10d34f: eb ac jmp 10d2fd <_Watchdog_Remove+0x15> <== NOT EXECUTED 0010d354 <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 10d354: 55 push %ebp <== NOT EXECUTED 10d355: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d357: 57 push %edi <== NOT EXECUTED 10d358: 56 push %esi <== NOT EXECUTED 10d359: 53 push %ebx <== NOT EXECUTED 10d35a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d35d: 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 ); 10d360: 9c pushf <== NOT EXECUTED 10d361: fa cli <== NOT EXECUTED 10d362: 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( 10d363: 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 10d365: 8d 47 04 lea 0x4(%edi),%eax <== NOT EXECUTED 10d368: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED if ( _Chain_Is_empty( header ) ) 10d36b: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10d36d: 74 11 je 10d380 <_Watchdog_Tickle+0x2c> <== NOT EXECUTED 10d36f: 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) { 10d371: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10d374: 85 c0 test %eax,%eax <== NOT EXECUTED 10d376: 74 34 je 10d3ac <_Watchdog_Tickle+0x58> <== NOT EXECUTED the_watchdog->delta_interval--; 10d378: 48 dec %eax <== NOT EXECUTED 10d379: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED if ( the_watchdog->delta_interval != 0 ) 10d37c: 85 c0 test %eax,%eax <== NOT EXECUTED 10d37e: 74 2c je 10d3ac <_Watchdog_Tickle+0x58> <== NOT EXECUTED the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); 10d380: 56 push %esi <== NOT EXECUTED 10d381: 9d popf <== NOT EXECUTED } 10d382: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d385: 5b pop %ebx <== NOT EXECUTED 10d386: 5e pop %esi <== NOT EXECUTED 10d387: 5f pop %edi <== NOT EXECUTED 10d388: c9 leave <== NOT EXECUTED 10d389: c3 ret <== NOT EXECUTED _ISR_Enable( level ); switch( watchdog_state ) { case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 10d38a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d38d: ff 73 24 pushl 0x24(%ebx) <== NOT EXECUTED 10d390: ff 73 20 pushl 0x20(%ebx) <== NOT EXECUTED 10d393: ff 53 1c call *0x1c(%ebx) <== NOT EXECUTED 10d396: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 10d399: 9c pushf <== NOT EXECUTED 10d39a: fa cli <== NOT EXECUTED 10d39b: 5e pop %esi <== NOT EXECUTED 10d39c: 8b 07 mov (%edi),%eax <== NOT EXECUTED the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 10d39e: 39 45 f0 cmp %eax,-0x10(%ebp) <== NOT EXECUTED 10d3a1: 74 dd je 10d380 <_Watchdog_Tickle+0x2c> <== NOT EXECUTED 10d3a3: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10d3a5: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 10d3a8: 85 c0 test %eax,%eax <== NOT EXECUTED 10d3aa: 75 d4 jne 10d380 <_Watchdog_Tickle+0x2c> <== NOT EXECUTED if ( the_watchdog->delta_interval != 0 ) goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 10d3ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d3af: 53 push %ebx <== NOT EXECUTED 10d3b0: e8 33 ff ff ff call 10d2e8 <_Watchdog_Remove> <== NOT EXECUTED _ISR_Enable( level ); 10d3b5: 56 push %esi <== NOT EXECUTED 10d3b6: 9d popf <== NOT EXECUTED switch( watchdog_state ) { 10d3b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d3ba: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10d3bd: 75 da jne 10d399 <_Watchdog_Tickle+0x45> <== NOT EXECUTED 10d3bf: eb c9 jmp 10d38a <_Watchdog_Tickle+0x36> <== NOT EXECUTED 0010d3dc <_Workspace_Allocate>: * _Workspace_Allocate */ void *_Workspace_Allocate( size_t size ) { 10d3dc: 55 push %ebp <== NOT EXECUTED 10d3dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d3df: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _Heap_Allocate( &_Workspace_Area, size ); 10d3e2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d3e5: 68 20 ea 11 00 push $0x11ea20 <== NOT EXECUTED 10d3ea: e8 71 1e 00 00 call 10f260 <_Heap_Allocate> <== NOT EXECUTED } 10d3ef: c9 leave <== NOT EXECUTED 10d3f0: c3 ret <== NOT EXECUTED 0010d3f4 <_Workspace_Allocate_or_fatal_error>: * _Workspace_Allocate_or_fatal_error */ void *_Workspace_Allocate_or_fatal_error( size_t size ) { 10d3f4: 55 push %ebp <== NOT EXECUTED 10d3f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d3f7: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED */ void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 10d3fa: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d3fd: 68 20 ea 11 00 push $0x11ea20 <== NOT EXECUTED 10d402: e8 59 1e 00 00 call 10f260 <_Heap_Allocate> <== NOT EXECUTED { void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) 10d407: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d40a: 85 c0 test %eax,%eax <== NOT EXECUTED 10d40c: 74 02 je 10d410 <_Workspace_Allocate_or_fatal_error+0x1c> <== NOT EXECUTED TRUE, INTERNAL_ERROR_WORKSPACE_ALLOCATION ); return memory; } 10d40e: c9 leave <== NOT EXECUTED 10d40f: c3 ret <== NOT EXECUTED void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) _Internal_error_Occurred( 10d410: 50 push %eax <== NOT EXECUTED 10d411: 6a 04 push $0x4 <== NOT EXECUTED 10d413: 6a 01 push $0x1 <== NOT EXECUTED 10d415: 6a 00 push $0x0 <== NOT EXECUTED 10d417: e8 c0 e0 ff ff call 10b4dc <_Internal_error_Occurred> <== NOT EXECUTED 0010d3c4 <_Workspace_Free>: * _Workspace_Free */ bool _Workspace_Free( void *block ) { 10d3c4: 55 push %ebp <== NOT EXECUTED 10d3c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d3c7: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _Heap_Free( &_Workspace_Area, block ); 10d3ca: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d3cd: 68 20 ea 11 00 push $0x11ea20 <== NOT EXECUTED 10d3d2: e8 1d 1f 00 00 call 10f2f4 <_Heap_Free> <== NOT EXECUTED } 10d3d7: c9 leave <== NOT EXECUTED 10d3d8: c3 ret <== NOT EXECUTED 0010d41c <_Workspace_Handler_initialization>: */ void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 10d41c: 55 push %ebp <== NOT EXECUTED 10d41d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d41f: 57 push %edi <== NOT EXECUTED 10d420: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d423: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) 10d426: 85 d2 test %edx,%edx <== NOT EXECUTED 10d428: 74 2e je 10d458 <_Workspace_Handler_initialization+0x3c> <== NOT EXECUTED 10d42a: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 10d42d: 75 29 jne 10d458 <_Workspace_Handler_initialization+0x3c> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _Configuration_Table->do_zero_of_workspace ) 10d42f: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10d434: 80 78 28 00 cmpb $0x0,0x28(%eax) <== NOT EXECUTED 10d438: 75 2a jne 10d464 <_Workspace_Handler_initialization+0x48> <== NOT EXECUTED memset( starting_address, 0, size ); memory_available = _Heap_Initialize( 10d43a: 6a 04 push $0x4 <== NOT EXECUTED 10d43c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d43f: 52 push %edx <== NOT EXECUTED 10d440: 68 20 ea 11 00 push $0x11ea20 <== NOT EXECUTED 10d445: e8 aa de ff ff call 10b2f4 <_Heap_Initialize> <== NOT EXECUTED starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 10d44a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d44d: 85 c0 test %eax,%eax <== NOT EXECUTED 10d44f: 74 1e je 10d46f <_Workspace_Handler_initialization+0x53> <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); } 10d451: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 10d454: c9 leave <== NOT EXECUTED 10d455: c3 ret <== NOT EXECUTED 10d456: 66 90 xchg %ax,%ax <== NOT EXECUTED ) { uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) _Internal_error_Occurred( 10d458: 51 push %ecx <== NOT EXECUTED 10d459: 6a 02 push $0x2 <== NOT EXECUTED 10d45b: 6a 01 push $0x1 <== NOT EXECUTED 10d45d: 6a 00 push $0x0 <== NOT EXECUTED 10d45f: e8 78 e0 ff ff call 10b4dc <_Internal_error_Occurred> <== NOT EXECUTED TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _Configuration_Table->do_zero_of_workspace ) memset( starting_address, 0, size ); 10d464: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d466: 89 d7 mov %edx,%edi <== NOT EXECUTED 10d468: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10d46b: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 10d46d: eb cb jmp 10d43a <_Workspace_Handler_initialization+0x1e> <== NOT EXECUTED size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) _Internal_error_Occurred( 10d46f: 52 push %edx <== NOT EXECUTED 10d470: 6a 03 push $0x3 <== NOT EXECUTED 10d472: 6a 01 push $0x1 <== NOT EXECUTED 10d474: 6a 00 push $0x0 <== NOT EXECUTED 10d476: e8 61 e0 ff ff call 10b4dc <_Internal_error_Occurred> <== NOT EXECUTED 0010a748 : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 10a748: 55 push %ebp <== NOT EXECUTED 10a749: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a74b: 56 push %esi <== NOT EXECUTED 10a74c: 53 push %ebx <== NOT EXECUTED 10a74d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10a750: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 10a753: 85 f6 test %esi,%esi <== NOT EXECUTED 10a755: 0f 84 8d 00 00 00 je 10a7e8 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 10a75b: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10a75e: 85 d2 test %edx,%edx <== NOT EXECUTED 10a760: 0f 84 ba 00 00 00 je 10a820 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 10a766: f6 45 0c 10 testb $0x10,0xc(%ebp) <== NOT EXECUTED 10a76a: 0f 84 84 00 00 00 je 10a7f4 <== NOT EXECUTED the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 10a770: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10a773: 85 c0 test %eax,%eax <== NOT EXECUTED 10a775: 0f 84 85 00 00 00 je 10a800 <== 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; 10a77b: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; the_attributes.maximum_count = maximum_waiters; 10a782: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10a785: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a788: a1 f8 16 12 00 mov 0x1216f8,%eax <== NOT EXECUTED 10a78d: 40 inc %eax <== NOT EXECUTED 10a78e: a3 f8 16 12 00 mov %eax,0x1216f8 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 10a793: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a796: 68 00 16 12 00 push $0x121600 <== NOT EXECUTED 10a79b: e8 50 1d 00 00 call 10c4f0 <_Objects_Allocate> <== NOT EXECUTED 10a7a0: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 10a7a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a7a5: 85 c0 test %eax,%eax <== NOT EXECUTED 10a7a7: 74 63 je 10a80c <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 10a7a9: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a7ac: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 10a7af: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a7b2: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10a7b5: 50 push %eax <== NOT EXECUTED 10a7b6: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 10a7b9: 50 push %eax <== NOT EXECUTED 10a7ba: e8 5d 14 00 00 call 10bc1c <_CORE_barrier_Initialize> <== NOT EXECUTED 10a7bf: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10a7c2: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10a7c5: a1 1c 16 12 00 mov 0x12161c,%eax <== NOT EXECUTED 10a7ca: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10a7cd: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 10a7d0: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a7d3: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a7d5: e8 4e 2a 00 00 call 10d228 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a7da: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a7dc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10a7df: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a7e2: 5b pop %ebx <== NOT EXECUTED 10a7e3: 5e pop %esi <== NOT EXECUTED 10a7e4: c9 leave <== NOT EXECUTED 10a7e5: c3 ret <== NOT EXECUTED 10a7e6: 66 90 xchg %ax,%ax <== NOT EXECUTED ) { Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 10a7e8: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10a7ed: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a7f0: 5b pop %ebx <== NOT EXECUTED 10a7f1: 5e pop %esi <== NOT EXECUTED 10a7f2: c9 leave <== NOT EXECUTED 10a7f3: c3 ret <== NOT EXECUTED if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; 10a7f4: c7 45 f0 01 00 00 00 movl $0x1,-0x10(%ebp) <== NOT EXECUTED 10a7fb: eb 85 jmp 10a782 <== NOT EXECUTED 10a7fd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 10a800: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10a805: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a808: 5b pop %ebx <== NOT EXECUTED 10a809: 5e pop %esi <== NOT EXECUTED 10a80a: c9 leave <== NOT EXECUTED 10a80b: c3 ret <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { _Thread_Enable_dispatch(); 10a80c: e8 17 2a 00 00 call 10d228 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a811: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10a816: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a819: 5b pop %ebx <== NOT EXECUTED 10a81a: 5e pop %esi <== NOT EXECUTED 10a81b: c9 leave <== NOT EXECUTED 10a81c: c3 ret <== NOT EXECUTED 10a81d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 10a820: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a825: eb b8 jmp 10a7df <== NOT EXECUTED 0010a828 : */ rtems_status_code rtems_barrier_delete( rtems_id id ) { 10a828: 55 push %ebp <== NOT EXECUTED 10a829: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a82b: 53 push %ebx <== NOT EXECUTED 10a82c: 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 10a82f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a832: 50 push %eax <== NOT EXECUTED 10a833: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a836: 68 00 16 12 00 push $0x121600 <== NOT EXECUTED 10a83b: e8 a4 21 00 00 call 10c9e4 <_Objects_Get> <== NOT EXECUTED 10a840: 89 c3 mov %eax,%ebx <== NOT EXECUTED Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 10a842: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a845: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10a848: 85 c0 test %eax,%eax <== NOT EXECUTED 10a84a: 75 38 jne 10a884 <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_barrier_Flush( 10a84c: 50 push %eax <== NOT EXECUTED 10a84d: 6a 02 push $0x2 <== NOT EXECUTED 10a84f: 6a 00 push $0x0 <== NOT EXECUTED 10a851: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 10a854: 50 push %eax <== NOT EXECUTED 10a855: e8 d6 30 00 00 call 10d930 <_Thread_queue_Flush> <== NOT EXECUTED &the_barrier->Barrier, NULL, CORE_BARRIER_WAS_DELETED ); _Objects_Close( &_Barrier_Information, &the_barrier->Object ); 10a85a: 59 pop %ecx <== NOT EXECUTED 10a85b: 58 pop %eax <== NOT EXECUTED 10a85c: 53 push %ebx <== NOT EXECUTED 10a85d: 68 00 16 12 00 push $0x121600 <== NOT EXECUTED 10a862: e8 09 1d 00 00 call 10c570 <_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 10a867: 58 pop %eax <== NOT EXECUTED 10a868: 5a pop %edx <== NOT EXECUTED 10a869: 53 push %ebx <== NOT EXECUTED 10a86a: 68 00 16 12 00 push $0x121600 <== NOT EXECUTED 10a86f: e8 3c 20 00 00 call 10c8b0 <_Objects_Free> <== NOT EXECUTED _Barrier_Free( the_barrier ); _Thread_Enable_dispatch(); 10a874: e8 af 29 00 00 call 10d228 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a879: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a87b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a87e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a881: c9 leave <== NOT EXECUTED 10a882: c3 ret <== NOT EXECUTED 10a883: 90 nop <== NOT EXECUTED { Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 10a884: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a889: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a88c: c9 leave <== NOT EXECUTED 10a88d: c3 ret <== NOT EXECUTED 0010a890 : rtems_status_code rtems_barrier_ident( rtems_name name, rtems_id *id ) { 10a890: 55 push %ebp <== NOT EXECUTED 10a891: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a893: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 10a896: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a899: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 10a89e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a8a1: 68 00 16 12 00 push $0x121600 <== NOT EXECUTED 10a8a6: e8 91 22 00 00 call 10cb3c <_Objects_Name_to_id_u32> <== NOT EXECUTED 10a8ab: 8b 04 85 8c b2 11 00 mov 0x11b28c(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 10a8b2: c9 leave <== NOT EXECUTED 10a8b3: c3 ret <== NOT EXECUTED 0010a8b4 : rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) { 10a8b4: 55 push %ebp <== NOT EXECUTED 10a8b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a8b7: 56 push %esi <== NOT EXECUTED 10a8b8: 53 push %ebx <== NOT EXECUTED 10a8b9: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10a8bc: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a8bf: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 10a8c2: 85 f6 test %esi,%esi <== NOT EXECUTED 10a8c4: 74 46 je 10a90c <== 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 10a8c6: 50 push %eax <== NOT EXECUTED 10a8c7: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10a8ca: 50 push %eax <== NOT EXECUTED 10a8cb: 53 push %ebx <== NOT EXECUTED 10a8cc: 68 00 16 12 00 push $0x121600 <== NOT EXECUTED 10a8d1: e8 0e 21 00 00 call 10c9e4 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 10a8d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a8d9: 8b 4d f4 mov -0xc(%ebp),%ecx <== NOT EXECUTED 10a8dc: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a8de: 74 0c je 10a8ec <== NOT EXECUTED 10a8e0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a8e5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a8e8: 5b pop %ebx <== NOT EXECUTED 10a8e9: 5e pop %esi <== NOT EXECUTED 10a8ea: c9 leave <== NOT EXECUTED 10a8eb: c3 ret <== NOT EXECUTED the_barrier = _Barrier_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: *released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL ); 10a8ec: 52 push %edx <== NOT EXECUTED 10a8ed: 6a 00 push $0x0 <== NOT EXECUTED 10a8ef: 53 push %ebx <== NOT EXECUTED 10a8f0: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 10a8f3: 50 push %eax <== NOT EXECUTED 10a8f4: e8 57 13 00 00 call 10bc50 <_CORE_barrier_Release> <== NOT EXECUTED 10a8f9: 89 06 mov %eax,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a8fb: e8 28 29 00 00 call 10d228 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a900: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a902: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a905: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a908: 5b pop %ebx <== NOT EXECUTED 10a909: 5e pop %esi <== NOT EXECUTED 10a90a: c9 leave <== NOT EXECUTED 10a90b: c3 ret <== NOT EXECUTED ) { Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 10a90c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a911: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a914: 5b pop %ebx <== NOT EXECUTED 10a915: 5e pop %esi <== NOT EXECUTED 10a916: c9 leave <== NOT EXECUTED 10a917: c3 ret <== NOT EXECUTED 0010a918 : rtems_status_code rtems_barrier_wait( rtems_id id, rtems_interval timeout ) { 10a918: 55 push %ebp <== NOT EXECUTED 10a919: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a91b: 53 push %ebx <== NOT EXECUTED 10a91c: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10a91f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a922: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a925: 50 push %eax <== NOT EXECUTED 10a926: 53 push %ebx <== NOT EXECUTED 10a927: 68 00 16 12 00 push $0x121600 <== NOT EXECUTED 10a92c: e8 b3 20 00 00 call 10c9e4 <_Objects_Get> <== NOT EXECUTED Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 10a931: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a934: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10a937: 85 d2 test %edx,%edx <== NOT EXECUTED 10a939: 75 35 jne 10a970 <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_barrier_Wait( 10a93b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a93e: 6a 00 push $0x0 <== NOT EXECUTED 10a940: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a943: 6a 01 push $0x1 <== NOT EXECUTED 10a945: 53 push %ebx <== NOT EXECUTED 10a946: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 10a949: 50 push %eax <== NOT EXECUTED 10a94a: e8 31 13 00 00 call 10bc80 <_CORE_barrier_Wait> <== NOT EXECUTED id, TRUE, timeout, NULL ); _Thread_Enable_dispatch(); 10a94f: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10a952: e8 d1 28 00 00 call 10d228 <_Thread_Enable_dispatch> <== NOT EXECUTED return _Barrier_Translate_core_barrier_return_code( 10a957: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a95a: a1 bc 17 12 00 mov 0x1217bc,%eax <== NOT EXECUTED 10a95f: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10a962: e8 89 52 00 00 call 10fbf0 <_Barrier_Translate_core_barrier_return_code> <== NOT EXECUTED 10a967: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a96a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a96d: c9 leave <== NOT EXECUTED 10a96e: c3 ret <== NOT EXECUTED 10a96f: 90 nop <== NOT EXECUTED { Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 10a970: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a975: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a978: c9 leave <== NOT EXECUTED 10a979: c3 ret <== NOT EXECUTED 0010b678 : uint32_t api, uint32_t class, uint32_t node, uint32_t index ) { 10b678: 55 push %ebp <== NOT EXECUTED 10b679: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b67b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b67e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b681: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10b684: c1 e0 1b shl $0x1b,%eax <== NOT EXECUTED 10b687: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10b68a: 09 d0 or %edx,%eax <== NOT EXECUTED 10b68c: 0b 45 14 or 0x14(%ebp),%eax <== NOT EXECUTED 10b68f: c1 e1 10 shl $0x10,%ecx <== NOT EXECUTED 10b692: 09 c8 or %ecx,%eax <== NOT EXECUTED return _Objects_Build_id( api, class, node, index ); } 10b694: c9 leave <== NOT EXECUTED 10b695: c3 ret <== NOT EXECUTED 0010b698 : char C1, char C2, char C3, char C4 ) { 10b698: 55 push %ebp <== NOT EXECUTED 10b699: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b69b: 0f be 45 0c movsbl 0xc(%ebp),%eax <== NOT EXECUTED 10b69f: c1 e0 10 shl $0x10,%eax <== NOT EXECUTED 10b6a2: 0f be 55 08 movsbl 0x8(%ebp),%edx <== NOT EXECUTED 10b6a6: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10b6a9: 09 d0 or %edx,%eax <== NOT EXECUTED 10b6ab: 0f be 55 10 movsbl 0x10(%ebp),%edx <== NOT EXECUTED 10b6af: c1 e2 08 shl $0x8,%edx <== NOT EXECUTED 10b6b2: 09 d0 or %edx,%eax <== NOT EXECUTED 10b6b4: 0f be 55 14 movsbl 0x14(%ebp),%edx <== NOT EXECUTED 10b6b8: 09 d0 or %edx,%eax <== NOT EXECUTED return _Objects_Build_name( C1, C2, C3, C4 ); } 10b6ba: c9 leave <== NOT EXECUTED 10b6bb: c3 ret <== NOT EXECUTED 00109acc : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 109acc: 55 push %ebp <== NOT EXECUTED 109acd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109acf: 53 push %ebx <== NOT EXECUTED 109ad0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 109ad3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109ad6: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED if ( !time_buffer ) 109ad9: 85 db test %ebx,%ebx <== NOT EXECUTED 109adb: 74 5b je 109b38 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; switch ( option ) { 109add: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 109ae0: 76 0a jbe 109aec <== NOT EXECUTED 109ae2: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 109ae7: 5a pop %edx <== NOT EXECUTED 109ae8: 5b pop %ebx <== NOT EXECUTED 109ae9: c9 leave <== NOT EXECUTED 109aea: c3 ret <== NOT EXECUTED 109aeb: 90 nop <== NOT EXECUTED ) { if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; switch ( option ) { 109aec: ff 24 85 08 85 11 00 jmp *0x118508(,%eax,4) <== NOT EXECUTED 109af3: 90 nop <== 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 ); 109af4: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 109af7: 59 pop %ecx <== NOT EXECUTED 109af8: 5b pop %ebx <== NOT EXECUTED 109af9: 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 ); 109afa: e9 3d 01 00 00 jmp 109c3c <== NOT EXECUTED 109aff: 90 nop <== 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(); 109b00: e8 6b 00 00 00 call 109b70 <== NOT EXECUTED 109b05: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 109b07: 31 c0 xor %eax,%eax <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 109b09: 5a pop %edx <== NOT EXECUTED 109b0a: 5b pop %ebx <== NOT EXECUTED 109b0b: c9 leave <== NOT EXECUTED 109b0c: c3 ret <== NOT EXECUTED 109b0d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_since_boot(); 109b10: e8 6f 00 00 00 call 109b84 <== NOT EXECUTED 109b15: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 109b17: 31 c0 xor %eax,%eax <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 109b19: 5a pop %edx <== NOT EXECUTED 109b1a: 5b pop %ebx <== NOT EXECUTED 109b1b: c9 leave <== NOT EXECUTED 109b1c: c3 ret <== NOT EXECUTED 109b1d: 8d 76 00 lea 0x0(%esi),%esi <== 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); 109b20: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 109b23: 5b pop %ebx <== NOT EXECUTED 109b24: 5b pop %ebx <== NOT EXECUTED 109b25: 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); 109b26: e9 15 00 00 00 jmp 109b40 <== NOT EXECUTED 109b2b: 90 nop <== 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 ); 109b2c: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 109b2f: 58 pop %eax <== NOT EXECUTED 109b30: 5b pop %ebx <== NOT EXECUTED 109b31: 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 ); 109b32: e9 59 00 00 00 jmp 109b90 <== NOT EXECUTED 109b37: 90 nop <== NOT EXECUTED rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { if ( !time_buffer ) 109b38: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 109b3d: eb a8 jmp 109ae7 <== NOT EXECUTED 00109b40 : #include rtems_status_code rtems_clock_get_seconds_since_epoch( rtems_interval *the_interval ) { 109b40: 55 push %ebp <== NOT EXECUTED 109b41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109b43: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !the_interval ) 109b46: 85 d2 test %edx,%edx <== NOT EXECUTED 109b48: 74 1e je 109b68 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 109b4a: 80 3d 0c ea 11 00 00 cmpb $0x0,0x11ea0c <== NOT EXECUTED 109b51: 74 0d je 109b60 <== NOT EXECUTED return RTEMS_NOT_DEFINED; *the_interval = _TOD_Seconds_since_epoch; 109b53: a1 8c ea 11 00 mov 0x11ea8c,%eax <== NOT EXECUTED 109b58: 89 02 mov %eax,(%edx) <== NOT EXECUTED 109b5a: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 109b5c: c9 leave <== NOT EXECUTED 109b5d: c3 ret <== NOT EXECUTED 109b5e: 66 90 xchg %ax,%ax <== NOT EXECUTED ) { if ( !the_interval ) return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 109b60: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED return RTEMS_NOT_DEFINED; *the_interval = _TOD_Seconds_since_epoch; return RTEMS_SUCCESSFUL; } 109b65: c9 leave <== NOT EXECUTED 109b66: c3 ret <== NOT EXECUTED 109b67: 90 nop <== NOT EXECUTED rtems_status_code rtems_clock_get_seconds_since_epoch( rtems_interval *the_interval ) { if ( !the_interval ) 109b68: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; *the_interval = _TOD_Seconds_since_epoch; return RTEMS_SUCCESSFUL; } 109b6d: c9 leave <== NOT EXECUTED 109b6e: c3 ret <== NOT EXECUTED 00109b70 : #include #include #include rtems_interval rtems_clock_get_ticks_per_second(void) { 109b70: 55 push %ebp <== NOT EXECUTED 109b71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109b73: b8 40 42 0f 00 mov $0xf4240,%eax <== NOT EXECUTED 109b78: 31 d2 xor %edx,%edx <== NOT EXECUTED 109b7a: f7 35 c0 eb 11 00 divl 0x11ebc0 <== NOT EXECUTED return TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick; } 109b80: c9 leave <== NOT EXECUTED 109b81: c3 ret <== NOT EXECUTED 00109b84 : #include #include #include rtems_interval rtems_clock_get_ticks_since_boot(void) { 109b84: 55 push %ebp <== NOT EXECUTED 109b85: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Watchdog_Ticks_since_boot; 109b87: a1 64 eb 11 00 mov 0x11eb64,%eax <== NOT EXECUTED } 109b8c: c9 leave <== NOT EXECUTED 109b8d: c3 ret <== NOT EXECUTED 00109b90 : #include rtems_status_code rtems_clock_get_tod( rtems_time_of_day *time_buffer ) { 109b90: 55 push %ebp <== NOT EXECUTED 109b91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109b93: 56 push %esi <== NOT EXECUTED 109b94: 53 push %ebx <== NOT EXECUTED 109b95: 83 ec 40 sub $0x40,%esp <== NOT EXECUTED 109b98: 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 ) 109b9b: 85 f6 test %esi,%esi <== NOT EXECUTED 109b9d: 0f 84 8d 00 00 00 je 109c30 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 109ba3: 80 3d 0c ea 11 00 00 cmpb $0x0,0x11ea0c <== NOT EXECUTED 109baa: 75 0c jne 109bb8 <== NOT EXECUTED 109bac: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; return RTEMS_SUCCESSFUL; } 109bb1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109bb4: 5b pop %ebx <== NOT EXECUTED 109bb5: 5e pop %esi <== NOT EXECUTED 109bb6: c9 leave <== NOT EXECUTED 109bb7: c3 ret <== NOT EXECUTED ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** 109bb8: 9c pushf <== NOT EXECUTED 109bb9: fa cli <== NOT EXECUTED 109bba: 5b pop %ebx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 109bbb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109bbe: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 109bc1: 50 push %eax <== NOT EXECUTED 109bc2: e8 31 16 00 00 call 10b1f8 <_TOD_Get> <== NOT EXECUTED * begin at @a starting_address. 109bc7: 53 push %ebx <== NOT EXECUTED 109bc8: 9d popf <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon 109bc9: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 109bcc: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory 109bcf: b8 d3 4d 62 10 mov $0x10624dd3,%eax <== NOT EXECUTED 109bd4: f7 65 ec mull -0x14(%ebp) <== NOT EXECUTED 109bd7: c1 ea 06 shr $0x6,%edx <== NOT EXECUTED 109bda: 89 55 f4 mov %edx,-0xc(%ebp) <== NOT EXECUTED /* Obtain the current time */ _TOD_Get_timeval( &now ); /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); 109bdd: 58 pop %eax <== NOT EXECUTED 109bde: 5a pop %edx <== NOT EXECUTED 109bdf: 8d 45 c4 lea -0x3c(%ebp),%eax <== NOT EXECUTED 109be2: 50 push %eax <== NOT EXECUTED 109be3: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 109be6: 50 push %eax <== NOT EXECUTED 109be7: e8 14 6d 00 00 call 110900 <== NOT EXECUTED /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; 109bec: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 109bef: 05 6c 07 00 00 add $0x76c,%eax <== NOT EXECUTED 109bf4: 89 06 mov %eax,(%esi) <== NOT EXECUTED tmbuf->month = time.tm_mon + 1; 109bf6: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 109bf9: 40 inc %eax <== NOT EXECUTED 109bfa: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED tmbuf->day = time.tm_mday; 109bfd: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 109c00: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED tmbuf->hour = time.tm_hour; 109c03: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 109c06: 89 46 0c mov %eax,0xc(%esi) <== NOT EXECUTED tmbuf->minute = time.tm_min; 109c09: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 109c0c: 89 46 10 mov %eax,0x10(%esi) <== NOT EXECUTED tmbuf->second = time.tm_sec; 109c0f: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED 109c12: 89 46 14 mov %eax,0x14(%esi) <== NOT EXECUTED tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 109c15: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 109c18: 31 d2 xor %edx,%edx <== NOT EXECUTED 109c1a: f7 35 c0 eb 11 00 divl 0x11ebc0 <== NOT EXECUTED 109c20: 89 46 18 mov %eax,0x18(%esi) <== NOT EXECUTED 109c23: 31 c0 xor %eax,%eax <== NOT EXECUTED 109c25: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 109c28: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109c2b: 5b pop %ebx <== NOT EXECUTED 109c2c: 5e pop %esi <== NOT EXECUTED 109c2d: c9 leave <== NOT EXECUTED 109c2e: c3 ret <== NOT EXECUTED 109c2f: 90 nop <== NOT EXECUTED { rtems_time_of_day *tmbuf = time_buffer; struct tm time; struct timeval now; if ( !time_buffer ) 109c30: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 109c35: e9 77 ff ff ff jmp 109bb1 <== NOT EXECUTED 00109c3c : #include rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { 109c3c: 55 push %ebp <== NOT EXECUTED 109c3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109c3f: 56 push %esi <== NOT EXECUTED 109c40: 53 push %ebx <== NOT EXECUTED 109c41: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 109c44: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED if ( !time ) 109c47: 85 f6 test %esi,%esi <== NOT EXECUTED 109c49: 74 45 je 109c90 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 109c4b: 80 3d 0c ea 11 00 00 cmpb $0x0,0x11ea0c <== NOT EXECUTED 109c52: 75 0c jne 109c60 <== NOT EXECUTED 109c54: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED return RTEMS_NOT_DEFINED; _TOD_Get_timeval( time ); return RTEMS_SUCCESSFUL; } 109c59: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109c5c: 5b pop %ebx <== NOT EXECUTED 109c5d: 5e pop %esi <== NOT EXECUTED 109c5e: c9 leave <== NOT EXECUTED 109c5f: c3 ret <== NOT EXECUTED ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** 109c60: 9c pushf <== NOT EXECUTED 109c61: fa cli <== NOT EXECUTED 109c62: 5b pop %ebx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 109c63: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109c66: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 109c69: 50 push %eax <== NOT EXECUTED 109c6a: e8 89 15 00 00 call 10b1f8 <_TOD_Get> <== NOT EXECUTED * begin at @a starting_address. 109c6f: 53 push %ebx <== NOT EXECUTED 109c70: 9d popf <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon 109c71: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 109c74: 89 06 mov %eax,(%esi) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory 109c76: b8 d3 4d 62 10 mov $0x10624dd3,%eax <== NOT EXECUTED 109c7b: f7 65 f4 mull -0xc(%ebp) <== NOT EXECUTED 109c7e: c1 ea 06 shr $0x6,%edx <== NOT EXECUTED 109c81: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED 109c84: 31 c0 xor %eax,%eax <== NOT EXECUTED 109c86: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109c89: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109c8c: 5b pop %ebx <== NOT EXECUTED 109c8d: 5e pop %esi <== NOT EXECUTED 109c8e: c9 leave <== NOT EXECUTED 109c8f: c3 ret <== NOT EXECUTED rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { if ( !time ) 109c90: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 109c95: eb c2 jmp 109c59 <== NOT EXECUTED 00109eb8 : * error code - if unsuccessful */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { 109eb8: 55 push %ebp <== NOT EXECUTED 109eb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109ebb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109ebe: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !uptime ) 109ec1: 85 c0 test %eax,%eax <== NOT EXECUTED 109ec3: 74 13 je 109ed8 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime( uptime ); 109ec5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109ec8: 50 push %eax <== NOT EXECUTED 109ec9: e8 fe 16 00 00 call 10b5cc <_TOD_Get_uptime> <== NOT EXECUTED 109ece: 31 c0 xor %eax,%eax <== NOT EXECUTED 109ed0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 109ed3: c9 leave <== NOT EXECUTED 109ed4: c3 ret <== NOT EXECUTED 109ed5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { if ( !uptime ) 109ed8: b0 09 mov $0x9,%al <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime( uptime ); return RTEMS_SUCCESSFUL; } 109eda: c9 leave <== NOT EXECUTED 109edb: c3 ret <== NOT EXECUTED 0010ab5c : */ rtems_status_code rtems_clock_set( rtems_time_of_day *time_buffer ) { 10ab5c: 55 push %ebp <== NOT EXECUTED 10ab5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ab5f: 53 push %ebx <== NOT EXECUTED 10ab60: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10ab63: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED struct timespec newtime; if ( !time_buffer ) 10ab66: 85 db test %ebx,%ebx <== NOT EXECUTED 10ab68: 74 66 je 10abd0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( time_buffer ) ) { 10ab6a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab6d: 53 push %ebx <== NOT EXECUTED 10ab6e: e8 3d 01 00 00 call 10acb0 <_TOD_Validate> <== NOT EXECUTED 10ab73: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ab76: 84 c0 test %al,%al <== NOT EXECUTED 10ab78: 75 0a jne 10ab84 <== NOT EXECUTED 10ab7a: b8 14 00 00 00 mov $0x14,%eax <== NOT EXECUTED _TOD_Set( &newtime ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; } 10ab7f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ab82: c9 leave <== NOT EXECUTED 10ab83: c3 ret <== NOT EXECUTED if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( time_buffer ) ) { newtime.tv_sec = _TOD_To_seconds( time_buffer ); 10ab84: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab87: 53 push %ebx <== NOT EXECUTED 10ab88: e8 93 00 00 00 call 10ac20 <_TOD_To_seconds> <== NOT EXECUTED 10ab8d: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED newtime.tv_nsec = time_buffer->ticks * 10ab90: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10ab93: 0f af 05 20 a7 12 00 imul 0x12a720,%eax <== NOT EXECUTED 10ab9a: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10ab9d: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10aba0: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10aba3: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED 10aba6: 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 10aba9: a1 58 a5 12 00 mov 0x12a558,%eax <== NOT EXECUTED 10abae: 40 inc %eax <== NOT EXECUTED 10abaf: a3 58 a5 12 00 mov %eax,0x12a558 <== NOT EXECUTED (_TOD_Microseconds_per_tick * TOD_NANOSECONDS_PER_MICROSECOND); _Thread_Disable_dispatch(); _TOD_Set( &newtime ); 10abb4: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10abb7: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10abba: e8 c9 19 00 00 call 10c588 <_TOD_Set> <== NOT EXECUTED _Thread_Enable_dispatch(); 10abbf: e8 b0 2b 00 00 call 10d774 <_Thread_Enable_dispatch> <== NOT EXECUTED 10abc4: 31 c0 xor %eax,%eax <== NOT EXECUTED 10abc6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; } 10abc9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10abcc: c9 leave <== NOT EXECUTED 10abcd: c3 ret <== NOT EXECUTED 10abce: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_time_of_day *time_buffer ) { struct timespec newtime; if ( !time_buffer ) 10abd0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED _TOD_Set( &newtime ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; } 10abd5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10abd8: c9 leave <== NOT EXECUTED 10abd9: c3 ret <== NOT EXECUTED 00109c98 : * error code - if unsuccessful */ rtems_status_code rtems_clock_set_nanoseconds_extension( rtems_nanoseconds_extension_routine routine ) { 109c98: 55 push %ebp <== NOT EXECUTED 109c99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109c9b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !routine ) 109c9e: 85 c0 test %eax,%eax <== NOT EXECUTED 109ca0: 74 0a je 109cac <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _Watchdog_Nanoseconds_since_tick_handler = routine; 109ca2: a3 c8 eb 11 00 mov %eax,0x11ebc8 <== NOT EXECUTED 109ca7: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 109ca9: c9 leave <== NOT EXECUTED 109caa: c3 ret <== NOT EXECUTED 109cab: 90 nop <== NOT EXECUTED */ rtems_status_code rtems_clock_set_nanoseconds_extension( rtems_nanoseconds_extension_routine routine ) { if ( !routine ) 109cac: b0 09 mov $0x9,%al <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _Watchdog_Nanoseconds_since_tick_handler = routine; return RTEMS_SUCCESSFUL; } 109cae: c9 leave <== NOT EXECUTED 109caf: c3 ret <== NOT EXECUTED 00109cb0 : * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) { 109cb0: 55 push %ebp <== NOT EXECUTED 109cb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109cb3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED _TOD_Tickle_ticks(); 109cb6: e8 cd 15 00 00 call 10b288 <_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 109cbb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109cbe: 68 dc ea 11 00 push $0x11eadc <== NOT EXECUTED 109cc3: e8 8c 36 00 00 call 10d354 <_Watchdog_Tickle> <== NOT EXECUTED _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 109cc8: e8 37 31 00 00 call 10ce04 <_Thread_Tickle_timeslice> <== NOT EXECUTED 109ccd: a0 cc ea 11 00 mov 0x11eacc,%al <== NOT EXECUTED if ( _Thread_Is_context_switch_necessary() && 109cd2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109cd5: 84 c0 test %al,%al <== NOT EXECUTED 109cd7: 74 09 je 109ce2 <== NOT EXECUTED 109cd9: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 109cde: 85 c0 test %eax,%eax <== NOT EXECUTED 109ce0: 74 06 je 109ce8 <== NOT EXECUTED _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); return RTEMS_SUCCESSFUL; } 109ce2: 31 c0 xor %eax,%eax <== NOT EXECUTED 109ce4: c9 leave <== NOT EXECUTED 109ce5: c3 ret <== NOT EXECUTED 109ce6: 66 90 xchg %ax,%ax <== NOT EXECUTED _Thread_Tickle_timeslice(); if ( _Thread_Is_context_switch_necessary() && _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 109ce8: e8 5f 24 00 00 call 10c14c <_Thread_Dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 109ced: 31 c0 xor %eax,%eax <== NOT EXECUTED 109cef: c9 leave <== NOT EXECUTED 109cf0: c3 ret <== NOT EXECUTED 0010ef78 : */ void rtems_debug_disable ( rtems_debug_control to_be_disabled ) { 10ef78: 55 push %ebp <== NOT EXECUTED 10ef79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ef7b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED _Debug_Level &= ~to_be_disabled; 10ef7e: f7 d0 not %eax <== NOT EXECUTED 10ef80: 21 05 c0 ea 11 00 and %eax,0x11eac0 <== NOT EXECUTED } 10ef86: c9 leave <== NOT EXECUTED 10ef87: c3 ret <== NOT EXECUTED 0010ef68 : */ void rtems_debug_enable ( rtems_debug_control to_be_enabled ) { 10ef68: 55 push %ebp <== NOT EXECUTED 10ef69: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Debug_Level |= to_be_enabled; 10ef6b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ef6e: 09 05 c0 ea 11 00 or %eax,0x11eac0 <== NOT EXECUTED } 10ef74: c9 leave <== NOT EXECUTED 10ef75: c3 ret <== NOT EXECUTED 00109cf4 : rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 109cf4: 55 push %ebp <== NOT EXECUTED 109cf5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109cf7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109cfa: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 109cfd: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED RTEMS_API_Control *api; if ( !event_out ) 109d00: 85 d2 test %edx,%edx <== NOT EXECUTED 109d02: 74 44 je 109d48 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; 109d04: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED 109d09: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED if ( _Event_sets_Is_empty( event_in ) ) { 109d0f: 85 c9 test %ecx,%ecx <== NOT EXECUTED 109d11: 75 09 jne 109d1c <== NOT EXECUTED *event_out = api->pending_events; 109d13: 8b 00 mov (%eax),%eax <== NOT EXECUTED 109d15: 89 02 mov %eax,(%edx) <== NOT EXECUTED 109d17: 31 c0 xor %eax,%eax <== NOT EXECUTED _Thread_Disable_dispatch(); _Event_Seize( event_in, option_set, ticks, event_out ); _Thread_Enable_dispatch(); return( _Thread_Executing->Wait.return_code ); } 109d19: c9 leave <== NOT EXECUTED 109d1a: c3 ret <== NOT EXECUTED 109d1b: 90 nop <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109d1c: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 109d21: 40 inc %eax <== NOT EXECUTED 109d22: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED *event_out = api->pending_events; return RTEMS_SUCCESSFUL; } _Thread_Disable_dispatch(); _Event_Seize( event_in, option_set, ticks, event_out ); 109d27: 52 push %edx <== NOT EXECUTED 109d28: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 109d2b: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109d2e: 51 push %ecx <== NOT EXECUTED 109d2f: e8 1c 00 00 00 call 109d50 <_Event_Seize> <== NOT EXECUTED _Thread_Enable_dispatch(); 109d34: e8 6f 25 00 00 call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED return( _Thread_Executing->Wait.return_code ); 109d39: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED 109d3e: 8b 40 34 mov 0x34(%eax),%eax <== NOT EXECUTED 109d41: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109d44: c9 leave <== NOT EXECUTED 109d45: c3 ret <== NOT EXECUTED 109d46: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_event_set *event_out ) { RTEMS_API_Control *api; if ( !event_out ) 109d48: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED _Thread_Disable_dispatch(); _Event_Seize( event_in, option_set, ticks, event_out ); _Thread_Enable_dispatch(); return( _Thread_Executing->Wait.return_code ); } 109d4d: c9 leave <== NOT EXECUTED 109d4e: c3 ret <== NOT EXECUTED 00109e88 : rtems_status_code rtems_event_send( Objects_Id id, rtems_event_set event_in ) { 109e88: 55 push %ebp <== NOT EXECUTED 109e89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109e8b: 53 push %ebx <== NOT EXECUTED 109e8c: 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 ); 109e8f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109e92: 50 push %eax <== NOT EXECUTED 109e93: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109e96: e8 31 24 00 00 call 10c2cc <_Thread_Get> <== NOT EXECUTED 109e9b: 89 c1 mov %eax,%ecx <== NOT EXECUTED switch ( location ) { 109e9d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109ea0: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 109ea3: 85 c0 test %eax,%eax <== NOT EXECUTED 109ea5: 75 29 jne 109ed0 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 109ea7: 8b 81 f4 00 00 00 mov 0xf4(%ecx),%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, 109ead: 9c pushf <== NOT EXECUTED 109eae: fa cli <== NOT EXECUTED 109eaf: 5a pop %edx <== NOT EXECUTED void *starting_address, 109eb0: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 109eb3: 09 18 or %ebx,(%eax) <== NOT EXECUTED size_t size, 109eb5: 52 push %edx <== NOT EXECUTED 109eb6: 9d popf <== NOT EXECUTED _Event_sets_Post( event_in, &api->pending_events ); _Event_Surrender( the_thread ); 109eb7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109eba: 51 push %ecx <== NOT EXECUTED 109ebb: e8 1c 00 00 00 call 109edc <_Event_Surrender> <== NOT EXECUTED _Thread_Enable_dispatch(); 109ec0: e8 e3 23 00 00 call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED 109ec5: 31 c0 xor %eax,%eax <== NOT EXECUTED 109ec7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 109eca: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109ecd: c9 leave <== NOT EXECUTED 109ece: c3 ret <== NOT EXECUTED 109ecf: 90 nop <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; the_thread = _Thread_Get( id, &location ); switch ( location ) { 109ed0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 109ed5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109ed8: c9 leave <== NOT EXECUTED 109ed9: c3 ret <== NOT EXECUTED 0010f730 : rtems_status_code rtems_extension_create( rtems_name name, rtems_extensions_table *extension_table, Objects_Id *id ) { 10f730: 55 push %ebp <== NOT EXECUTED 10f731: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f733: 57 push %edi <== NOT EXECUTED 10f734: 56 push %esi <== NOT EXECUTED 10f735: 53 push %ebx <== NOT EXECUTED 10f736: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f739: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10f73c: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Extension_Control *the_extension; if ( !id ) 10f73f: 85 f6 test %esi,%esi <== NOT EXECUTED 10f741: 74 75 je 10f7b8 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10f743: 85 ff test %edi,%edi <== NOT EXECUTED 10f745: 75 0d jne 10f754 <== NOT EXECUTED 10f747: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED ); *id = the_extension->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10f74c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f74f: 5b pop %ebx <== NOT EXECUTED 10f750: 5e pop %esi <== NOT EXECUTED 10f751: 5f pop %edi <== NOT EXECUTED 10f752: c9 leave <== NOT EXECUTED 10f753: c3 ret <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10f754: a1 d8 c9 12 00 mov 0x12c9d8,%eax <== NOT EXECUTED 10f759: 40 inc %eax <== NOT EXECUTED 10f75a: a3 d8 c9 12 00 mov %eax,0x12c9d8 <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 10f75f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f762: 68 60 cc 12 00 push $0x12cc60 <== NOT EXECUTED 10f767: e8 10 0c 00 00 call 11037c <_Objects_Allocate> <== NOT EXECUTED 10f76c: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 10f76e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f771: 85 c0 test %eax,%eax <== NOT EXECUTED 10f773: 74 37 je 10f7ac <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } _User_extensions_Add_set( &the_extension->Extension, extension_table ); 10f775: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f778: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10f77b: 8d 40 10 lea 0x10(%eax),%eax <== NOT EXECUTED 10f77e: 50 push %eax <== NOT EXECUTED 10f77f: e8 00 26 00 00 call 111d84 <_User_extensions_Add_set> <== NOT EXECUTED 10f784: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10f787: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10f78a: a1 7c cc 12 00 mov 0x12cc7c,%eax <== NOT EXECUTED 10f78f: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10f792: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 10f795: 89 0e mov %ecx,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10f797: e8 18 19 00 00 call 1110b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10f79c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f79e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10f7a1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f7a4: 5b pop %ebx <== NOT EXECUTED 10f7a5: 5e pop %esi <== NOT EXECUTED 10f7a6: 5f pop %edi <== NOT EXECUTED 10f7a7: c9 leave <== NOT EXECUTED 10f7a8: c3 ret <== NOT EXECUTED 10f7a9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { _Thread_Enable_dispatch(); 10f7ac: e8 03 19 00 00 call 1110b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10f7b1: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10f7b6: eb 94 jmp 10f74c <== NOT EXECUTED Objects_Id *id ) { Extension_Control *the_extension; if ( !id ) 10f7b8: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10f7bd: eb 8d jmp 10f74c <== NOT EXECUTED 0010f7c0 : */ rtems_status_code rtems_extension_delete( Objects_Id id ) { 10f7c0: 55 push %ebp <== NOT EXECUTED 10f7c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f7c3: 53 push %ebx <== NOT EXECUTED 10f7c4: 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 10f7c7: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10f7ca: 50 push %eax <== NOT EXECUTED 10f7cb: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f7ce: 68 60 cc 12 00 push $0x12cc60 <== NOT EXECUTED 10f7d3: e8 98 10 00 00 call 110870 <_Objects_Get> <== NOT EXECUTED 10f7d8: 89 c3 mov %eax,%ebx <== NOT EXECUTED Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 10f7da: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f7dd: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10f7e0: 85 c0 test %eax,%eax <== NOT EXECUTED 10f7e2: 75 38 jne 10f81c <== NOT EXECUTED case OBJECTS_LOCAL: _User_extensions_Remove_set( &the_extension->Extension ); 10f7e4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f7e7: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10f7ea: 50 push %eax <== NOT EXECUTED 10f7eb: e8 94 26 00 00 call 111e84 <_User_extensions_Remove_set> <== NOT EXECUTED _Objects_Close( &_Extension_Information, &the_extension->Object ); 10f7f0: 59 pop %ecx <== NOT EXECUTED 10f7f1: 58 pop %eax <== NOT EXECUTED 10f7f2: 53 push %ebx <== NOT EXECUTED 10f7f3: 68 60 cc 12 00 push $0x12cc60 <== NOT EXECUTED 10f7f8: e8 ff 0b 00 00 call 1103fc <_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 10f7fd: 58 pop %eax <== NOT EXECUTED 10f7fe: 5a pop %edx <== NOT EXECUTED 10f7ff: 53 push %ebx <== NOT EXECUTED 10f800: 68 60 cc 12 00 push $0x12cc60 <== NOT EXECUTED 10f805: e8 32 0f 00 00 call 11073c <_Objects_Free> <== NOT EXECUTED _Extension_Free( the_extension ); _Thread_Enable_dispatch(); 10f80a: e8 a5 18 00 00 call 1110b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10f80f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f811: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f814: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f817: c9 leave <== NOT EXECUTED 10f818: c3 ret <== NOT EXECUTED 10f819: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 10f81c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f821: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f824: c9 leave <== NOT EXECUTED 10f825: c3 ret <== NOT EXECUTED 0010c44c : rtems_status_code rtems_extension_ident( rtems_name name, Objects_Id *id ) { 10c44c: 55 push %ebp <== NOT EXECUTED 10c44d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c44f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 10c452: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c455: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 10c45a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c45d: 68 a0 2b 12 00 push $0x122ba0 <== NOT EXECUTED 10c462: e8 a9 11 00 00 call 10d610 <_Objects_Name_to_id_u32> <== NOT EXECUTED 10c467: 8b 04 85 ac c6 11 00 mov 0x11c6ac(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 10c46e: c9 leave <== NOT EXECUTED 10c46f: c3 ret <== NOT EXECUTED 0010aa40 : */ void rtems_fatal_error_occurred( uint32_t the_error ) { 10aa40: 55 push %ebp <== NOT EXECUTED 10aa41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa43: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, FALSE, the_error ); 10aa46: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10aa49: 6a 00 push $0x0 <== NOT EXECUTED 10aa4b: 6a 01 push $0x1 <== NOT EXECUTED 10aa4d: e8 8a 0a 00 00 call 10b4dc <_Internal_error_Occurred> <== NOT EXECUTED 0010c204 : #endif #include const char *rtems_get_version_string(void) { 10c204: 55 push %ebp <== NOT EXECUTED 10c205: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _RTEMS_version; } 10c207: b8 60 de 11 00 mov $0x11de60,%eax <== NOT EXECUTED 10c20c: c9 leave <== NOT EXECUTED 10c20d: c3 ret <== NOT EXECUTED 0010a900 : * Scheduling can properly occur now as long as we avoid dispatching. */ } void rtems_initialize_before_drivers(void) { 10a900: 55 push %ebp <== NOT EXECUTED 10a901: 89 e5 mov %esp,%ebp <== NOT EXECUTED * Run the API and BSPs predriver hook. */ _API_extensions_Run_predriver(); } 10a903: c9 leave <== NOT EXECUTED /* * Run the API and BSPs predriver hook. */ _API_extensions_Run_predriver(); 10a904: e9 ab 02 00 00 jmp 10abb4 <_API_extensions_Run_predriver> <== NOT EXECUTED 0010a90c : Objects_Information *_Internal_Objects[ OBJECTS_INTERNAL_CLASSES_LAST + 1 ]; void rtems_initialize_data_structures( rtems_configuration_table *configuration_table ) { 10a90c: 55 push %ebp <== NOT EXECUTED 10a90d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a90f: 53 push %ebx <== NOT EXECUTED 10a910: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a913: 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 ); 10a916: 9c pushf <== NOT EXECUTED 10a917: fa cli <== NOT EXECUTED 10a918: 58 pop %eax <== NOT EXECUTED /* * Make sure the parameters were not NULL. */ if ( configuration_table == NULL ) 10a919: 85 db test %ebx,%ebx <== NOT EXECUTED 10a91b: 0f 84 ec 00 00 00 je 10aa0d <== NOT EXECUTED ); /* * Provide pointers just for later convenience. */ _Configuration_Table = configuration_table; 10a921: 89 1d 94 ea 11 00 mov %ebx,0x11ea94 <== NOT EXECUTED /* * Initialize any target architecture specific support as early as possible */ _CPU_Initialize( _Thread_Dispatch ); 10a927: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a92a: 68 4c c1 10 00 push $0x10c14c <== NOT EXECUTED 10a92f: e8 0c 2d 00 00 call 10d640 <_CPU_Initialize> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** * This routine initializes @a the_heap record to manage the 10a934: c7 05 c4 eb 11 00 00 movl $0x0,0x11ebc4 <== NOT EXECUTED 10a93b: 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(); 10a93e: e8 15 46 00 00 call 10ef58 <_Debug_Manager_initialization> <== NOT EXECUTED _API_extensions_Initialization(); 10a943: e8 48 02 00 00 call 10ab90 <_API_extensions_Initialization> <== NOT EXECUTED 10a948: c7 05 f8 e9 11 00 01 movl $0x1,0x11e9f8 <== NOT EXECUTED 10a94f: 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( 10a952: 59 pop %ecx <== NOT EXECUTED 10a953: 58 pop %eax <== NOT EXECUTED 10a954: ff 73 04 pushl 0x4(%ebx) <== NOT EXECUTED 10a957: ff 33 pushl (%ebx) <== NOT EXECUTED 10a959: e8 be 2a 00 00 call 10d41c <_Workspace_Handler_initialization> <== NOT EXECUTED (void *)configuration_table->work_space_start, configuration_table->work_space_size ); _User_extensions_Handler_initialization( 10a95e: 58 pop %eax <== NOT EXECUTED 10a95f: 5a pop %edx <== NOT EXECUTED 10a960: ff 73 3c pushl 0x3c(%ebx) <== NOT EXECUTED 10a963: ff 73 38 pushl 0x38(%ebx) <== NOT EXECUTED 10a966: e8 e1 25 00 00 call 10cf4c <_User_extensions_Handler_initialization> <== NOT EXECUTED configuration_table->number_of_initial_extensions, configuration_table->User_extension_table ); _ISR_Handler_initialization(); 10a96b: e8 ac 0b 00 00 call 10b51c <_ISR_Handler_initialization> <== NOT EXECUTED _Objects_Handler_initialization( 10a970: e8 cb 12 00 00 call 10bc40 <_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; 10a975: c7 05 d0 e9 11 00 10 movl $0x11ea10,0x11e9d0 <== NOT EXECUTED 10a97c: ea 11 00 <== NOT EXECUTED /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 10a97f: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED 10a986: e8 5d 03 00 00 call 10ace8 <_API_Mutex_Initialization> <== NOT EXECUTED _API_Mutex_Allocate( &_RTEMS_Allocator_Mutex ); 10a98b: c7 04 24 b4 ea 11 00 movl $0x11eab4,(%esp) <== NOT EXECUTED 10a992: e8 d1 02 00 00 call 10ac68 <_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 10a997: 66 c7 05 b0 ea 11 00 movw $0x0,0x11eab0 <== NOT EXECUTED 10a99e: 00 00 <== NOT EXECUTED 10a9a0: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a9a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a9a5: 8d 76 00 lea 0x0(%esi),%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. 10a9a8: 66 c7 84 00 40 eb 11 movw $0x0,0x11eb40(%eax,%eax,1) <== NOT EXECUTED 10a9af: 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 10a9b2: 40 inc %eax <== NOT EXECUTED 10a9b3: 83 f8 10 cmp $0x10,%eax <== NOT EXECUTED 10a9b6: 75 f0 jne 10a9a8 <== NOT EXECUTED _Priority_Handler_initialization(); _Watchdog_Handler_initialization(); 10a9b8: e8 cb 28 00 00 call 10d288 <_Watchdog_Handler_initialization> <== NOT EXECUTED _TOD_Handler_initialization( configuration_table->microseconds_per_tick ); 10a9bd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a9c0: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 10a9c3: e8 84 08 00 00 call 10b24c <_TOD_Handler_initialization> <== NOT EXECUTED _Thread_Handler_initialization( 10a9c8: 5a pop %edx <== NOT EXECUTED 10a9c9: 59 pop %ecx <== NOT EXECUTED 10a9ca: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10a9cd: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10a9d0: e8 7f 1b 00 00 call 10c554 <_Thread_Handler_initialization> <== NOT EXECUTED ); #endif /* MANAGERS */ _RTEMS_API_Initialize( configuration_table ); 10a9d5: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a9d8: e8 2f 01 00 00 call 10ab0c <_RTEMS_API_Initialize> <== NOT EXECUTED _Extension_Manager_initialization( configuration_table->maximum_extensions ); 10a9dd: 58 pop %eax <== NOT EXECUTED 10a9de: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10a9e1: e8 36 00 00 00 call 10aa1c <_Extension_Manager_initialization> <== NOT EXECUTED _IO_Manager_initialization( 10a9e6: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10a9e9: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10a9ec: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10a9ef: ff 73 34 pushl 0x34(%ebx) <== NOT EXECUTED 10a9f2: e8 8d 00 00 00 call 10aa84 <_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( 10a9f7: c7 05 c4 eb 11 00 01 movl $0x1,0x11ebc4 <== NOT EXECUTED 10a9fe: 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(); 10aa01: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Scheduling can properly occur now as long as we avoid dispatching. */ } 10aa04: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10aa07: 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(); 10aa08: e9 67 16 00 00 jmp 10c074 <_Thread_Create_idle> <== NOT EXECUTED /* * Make sure the parameters were not NULL. */ if ( configuration_table == NULL ) _Internal_error_Occurred( 10aa0d: 50 push %eax <== NOT EXECUTED 10aa0e: 6a 00 push $0x0 <== NOT EXECUTED 10aa10: 6a 01 push $0x1 <== NOT EXECUTED 10aa12: 6a 00 push $0x0 <== NOT EXECUTED 10aa14: e8 c3 0a 00 00 call 10b4dc <_Internal_error_Occurred> <== NOT EXECUTED 0010a8ec : _API_extensions_Run_predriver(); } void rtems_initialize_device_drivers(void) { 10a8ec: 55 push %ebp <== NOT EXECUTED 10a8ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a8ef: 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(); 10a8f2: e8 5d 01 00 00 call 10aa54 <_IO_Initialize_all_drivers> <== NOT EXECUTED * * The API extensions are supposed to create user initialization tasks. */ _API_extensions_Run_postdriver(); } 10a8f7: 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(); 10a8f8: e9 e7 02 00 00 jmp 10abe4 <_API_extensions_Run_postdriver> <== NOT EXECUTED 0010a8d8 : _API_extensions_Run_postdriver(); } void rtems_initialize_start_multitasking(void) { 10a8d8: 55 push %ebp <== NOT EXECUTED 10a8d9: 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( 10a8db: c7 05 c4 eb 11 00 02 movl $0x2,0x11ebc4 <== NOT EXECUTED 10a8e2: 00 00 00 <== NOT EXECUTED ****** APPLICATION RUNS HERE ****** ****** RETURNS WHEN SYSTEM IS SHUT DOWN ****** ******************************************************************* ******************************************************************* *******************************************************************/ } 10a8e5: c9 leave <== NOT EXECUTED void rtems_initialize_start_multitasking(void) { _System_state_Set( SYSTEM_STATE_BEGIN_MULTITASKING ); _Thread_Start_multitasking(); 10a8e6: e9 5d 24 00 00 jmp 10cd48 <_Thread_Start_multitasking> <== NOT EXECUTED 0010a708 : rtems_status_code rtems_interrupt_catch( rtems_isr_entry new_isr_handler, rtems_vector_number vector, rtems_isr_entry *old_isr_handler ) { 10a708: 55 push %ebp <== NOT EXECUTED 10a709: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a70b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a70e: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a711: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED if ( !_ISR_Is_vector_number_valid( vector ) ) 10a714: 81 7d 0c ff 00 00 00 cmpl $0xff,0xc(%ebp) <== NOT EXECUTED 10a71b: 77 23 ja 10a740 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; if ( !_ISR_Is_valid_user_handler( (void *) new_isr_handler ) ) 10a71d: 85 d2 test %edx,%edx <== NOT EXECUTED 10a71f: 74 17 je 10a738 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_ISR_Is_valid_user_handler( (void *) old_isr_handler ) ) 10a721: 85 c0 test %eax,%eax <== NOT EXECUTED 10a723: 74 13 je 10a738 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _ISR_Install_vector( 10a725: 51 push %ecx <== NOT EXECUTED 10a726: 50 push %eax <== NOT EXECUTED 10a727: 52 push %edx <== NOT EXECUTED 10a728: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a72b: e8 b4 c5 ff ff call 106ce4 <_CPU_ISR_install_vector> <== NOT EXECUTED 10a730: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a732: 83 c4 10 add $0x10,%esp <== NOT EXECUTED vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler ); return RTEMS_SUCCESSFUL; } 10a735: c9 leave <== NOT EXECUTED 10a736: c3 ret <== NOT EXECUTED 10a737: 90 nop <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _ISR_Install_vector( vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler ); return RTEMS_SUCCESSFUL; 10a738: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED } 10a73d: c9 leave <== NOT EXECUTED 10a73e: c3 ret <== NOT EXECUTED 10a73f: 90 nop <== NOT EXECUTED rtems_isr_entry new_isr_handler, rtems_vector_number vector, rtems_isr_entry *old_isr_handler ) { if ( !_ISR_Is_vector_number_valid( vector ) ) 10a740: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED _ISR_Install_vector( vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler ); return RTEMS_SUCCESSFUL; } 10a745: c9 leave <== NOT EXECUTED 10a746: c3 ret <== NOT EXECUTED 0010acac : */ #undef rtems_interrupt_disable rtems_interrupt_level rtems_interrupt_disable( void ) { 10acac: 55 push %ebp <== NOT EXECUTED 10acad: 89 e5 mov %esp,%ebp <== NOT EXECUTED rtems_interrupt_level previous_level; _ISR_Disable( previous_level ); 10acaf: 9c pushf <== NOT EXECUTED 10acb0: fa cli <== NOT EXECUTED 10acb1: 58 pop %eax <== NOT EXECUTED return previous_level; } 10acb2: c9 leave <== NOT EXECUTED 10acb3: c3 ret <== NOT EXECUTED 0010acb4 : #undef rtems_interrupt_enable void rtems_interrupt_enable( rtems_interrupt_level previous_level ) { 10acb4: 55 push %ebp <== NOT EXECUTED 10acb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED _ISR_Enable( previous_level ); 10acb7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10acba: 9d popf <== NOT EXECUTED } 10acbb: c9 leave <== NOT EXECUTED 10acbc: c3 ret <== NOT EXECUTED 0010acc0 : #undef rtems_interrupt_flash void rtems_interrupt_flash( rtems_interrupt_level previous_level ) { 10acc0: 55 push %ebp <== NOT EXECUTED 10acc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED _ISR_Flash( previous_level ); 10acc3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10acc6: 9d popf <== NOT EXECUTED 10acc7: fa cli <== NOT EXECUTED } 10acc8: c9 leave <== NOT EXECUTED 10acc9: c3 ret <== NOT EXECUTED 0010accc : */ #undef rtems_interrupt_is_in_progress bool rtems_interrupt_is_in_progress( void ) { 10accc: 55 push %ebp <== NOT EXECUTED 10accd: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _ISR_Is_in_progress(); 10accf: a1 38 17 12 00 mov 0x121738,%eax <== NOT EXECUTED 10acd4: 85 c0 test %eax,%eax <== NOT EXECUTED 10acd6: 0f 95 c0 setne %al <== NOT EXECUTED } 10acd9: c9 leave <== NOT EXECUTED 10acda: c3 ret <== NOT EXECUTED 0010fe40 : rtems_status_code rtems_io_close( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10fe40: 55 push %ebp <== NOT EXECUTED 10fe41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fe43: 56 push %esi <== NOT EXECUTED 10fe44: 53 push %ebx <== NOT EXECUTED 10fe45: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10fe48: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10fe4b: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10fe4e: 39 0d a0 ed 11 00 cmp %ecx,0x11eda0 <== NOT EXECUTED 10fe54: 76 1e jbe 10fe74 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; 10fe56: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 10fe59: a1 a4 ed 11 00 mov 0x11eda4,%eax <== NOT EXECUTED 10fe5e: 8b 44 d0 08 mov 0x8(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10fe62: 85 c0 test %eax,%eax <== NOT EXECUTED 10fe64: 74 13 je 10fe79 <== NOT EXECUTED 10fe66: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10fe69: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10fe6c: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10fe6f: 5b pop %ebx <== NOT EXECUTED 10fe70: 5e pop %esi <== NOT EXECUTED 10fe71: 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; 10fe72: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10fe74: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 10fe79: 5b pop %ebx <== NOT EXECUTED 10fe7a: 5e pop %esi <== NOT EXECUTED 10fe7b: c9 leave <== NOT EXECUTED 10fe7c: c3 ret <== NOT EXECUTED 0010fe80 : rtems_status_code rtems_io_control( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10fe80: 55 push %ebp <== NOT EXECUTED 10fe81: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fe83: 56 push %esi <== NOT EXECUTED 10fe84: 53 push %ebx <== NOT EXECUTED 10fe85: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10fe88: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10fe8b: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10fe8e: 39 0d a0 ed 11 00 cmp %ecx,0x11eda0 <== NOT EXECUTED 10fe94: 76 1e jbe 10feb4 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; 10fe96: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 10fe99: a1 a4 ed 11 00 mov 0x11eda4,%eax <== NOT EXECUTED 10fe9e: 8b 44 d0 14 mov 0x14(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10fea2: 85 c0 test %eax,%eax <== NOT EXECUTED 10fea4: 74 13 je 10feb9 <== NOT EXECUTED 10fea6: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10fea9: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10feac: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10feaf: 5b pop %ebx <== NOT EXECUTED 10feb0: 5e pop %esi <== NOT EXECUTED 10feb1: 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; 10feb2: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10feb4: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 10feb9: 5b pop %ebx <== NOT EXECUTED 10feba: 5e pop %esi <== NOT EXECUTED 10febb: c9 leave <== NOT EXECUTED 10febc: c3 ret <== NOT EXECUTED 0010ef9c : rtems_status_code rtems_io_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10ef9c: 55 push %ebp <== NOT EXECUTED 10ef9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ef9f: 56 push %esi <== NOT EXECUTED 10efa0: 53 push %ebx <== NOT EXECUTED 10efa1: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10efa4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10efa7: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10efaa: 39 0d a0 ed 11 00 cmp %ecx,0x11eda0 <== NOT EXECUTED 10efb0: 76 1e jbe 10efd0 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; 10efb2: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 10efb5: a1 a4 ed 11 00 mov 0x11eda4,%eax <== NOT EXECUTED 10efba: 8b 04 d0 mov (%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10efbd: 85 c0 test %eax,%eax <== NOT EXECUTED 10efbf: 74 14 je 10efd5 <== NOT EXECUTED 10efc1: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10efc4: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10efc7: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10efca: 5b pop %ebx <== NOT EXECUTED 10efcb: 5e pop %esi <== NOT EXECUTED 10efcc: 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; 10efcd: ff e0 jmp *%eax <== NOT EXECUTED 10efcf: 90 nop <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10efd0: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 10efd5: 5b pop %ebx <== NOT EXECUTED 10efd6: 5e pop %esi <== NOT EXECUTED 10efd7: c9 leave <== NOT EXECUTED 10efd8: c3 ret <== NOT EXECUTED 0010fec0 : rtems_status_code rtems_io_open( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10fec0: 55 push %ebp <== NOT EXECUTED 10fec1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fec3: 56 push %esi <== NOT EXECUTED 10fec4: 53 push %ebx <== NOT EXECUTED 10fec5: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10fec8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10fecb: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10fece: 39 0d a0 ed 11 00 cmp %ecx,0x11eda0 <== NOT EXECUTED 10fed4: 76 1e jbe 10fef4 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; 10fed6: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 10fed9: a1 a4 ed 11 00 mov 0x11eda4,%eax <== NOT EXECUTED 10fede: 8b 44 d0 04 mov 0x4(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10fee2: 85 c0 test %eax,%eax <== NOT EXECUTED 10fee4: 74 13 je 10fef9 <== NOT EXECUTED 10fee6: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10fee9: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10feec: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10feef: 5b pop %ebx <== NOT EXECUTED 10fef0: 5e pop %esi <== NOT EXECUTED 10fef1: 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; 10fef2: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10fef4: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 10fef9: 5b pop %ebx <== NOT EXECUTED 10fefa: 5e pop %esi <== NOT EXECUTED 10fefb: c9 leave <== NOT EXECUTED 10fefc: c3 ret <== NOT EXECUTED 0010ff00 : rtems_status_code rtems_io_read( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10ff00: 55 push %ebp <== NOT EXECUTED 10ff01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ff03: 56 push %esi <== NOT EXECUTED 10ff04: 53 push %ebx <== NOT EXECUTED 10ff05: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ff08: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10ff0b: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10ff0e: 39 0d a0 ed 11 00 cmp %ecx,0x11eda0 <== NOT EXECUTED 10ff14: 76 1e jbe 10ff34 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; 10ff16: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 10ff19: a1 a4 ed 11 00 mov 0x11eda4,%eax <== NOT EXECUTED 10ff1e: 8b 44 d0 0c mov 0xc(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10ff22: 85 c0 test %eax,%eax <== NOT EXECUTED 10ff24: 74 13 je 10ff39 <== NOT EXECUTED 10ff26: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10ff29: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10ff2c: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10ff2f: 5b pop %ebx <== NOT EXECUTED 10ff30: 5e pop %esi <== NOT EXECUTED 10ff31: 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; 10ff32: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10ff34: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 10ff39: 5b pop %ebx <== NOT EXECUTED 10ff3a: 5e pop %esi <== NOT EXECUTED 10ff3b: c9 leave <== NOT EXECUTED 10ff3c: c3 ret <== NOT EXECUTED 0010b88c : 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 ) { 10b88c: 55 push %ebp <== NOT EXECUTED 10b88d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b88f: 57 push %edi <== NOT EXECUTED 10b890: 56 push %esi <== NOT EXECUTED 10b891: 53 push %ebx <== NOT EXECUTED 10b892: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b895: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b898: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10b89b: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 10b89e: 85 f6 test %esi,%esi <== NOT EXECUTED 10b8a0: 0f 84 c6 00 00 00 je 10b96c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 10b8a6: 85 db test %ebx,%ebx <== NOT EXECUTED 10b8a8: 0f 84 be 00 00 00 je 10b96c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 10b8ae: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10b8b0: 85 c0 test %eax,%eax <== NOT EXECUTED 10b8b2: 0f 84 a8 00 00 00 je 10b960 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; *registered_major = 0; 10b8b8: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 10b8be: a1 84 19 12 00 mov 0x121984,%eax <== NOT EXECUTED 10b8c3: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10b8c5: 76 5d jbe 10b924 <== NOT EXECUTED /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 10b8c7: 85 d2 test %edx,%edx <== NOT EXECUTED 10b8c9: 75 65 jne 10b930 <== NOT EXECUTED bool found = false; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 10b8cb: 89 c2 mov %eax,%edx <== NOT EXECUTED 10b8cd: 4a dec %edx <== NOT EXECUTED 10b8ce: 0f 84 80 00 00 00 je 10b954 <== NOT EXECUTED 10b8d4: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10b8d7: 8d 04 c5 e8 ff ff ff lea -0x18(,%eax,8),%eax <== NOT EXECUTED 10b8de: 03 05 88 19 12 00 add 0x121988,%eax <== NOT EXECUTED 10b8e4: eb 08 jmp 10b8ee <== NOT EXECUTED 10b8e6: 66 90 xchg %ax,%ax <== NOT EXECUTED 10b8e8: 83 e8 18 sub $0x18,%eax <== NOT EXECUTED 10b8eb: 4a dec %edx <== NOT EXECUTED 10b8ec: 74 66 je 10b954 <== NOT EXECUTED 10b8ee: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( !_IO_Driver_address_table[major].initialization_entry && 10b8f0: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10b8f2: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b8f4: 75 f2 jne 10b8e8 <== NOT EXECUTED 10b8f6: 8b 48 04 mov 0x4(%eax),%ecx <== NOT EXECUTED 10b8f9: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b8fb: 75 eb jne 10b8e8 <== NOT EXECUTED if ( _IO_Driver_address_table[major].initialization_entry || _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 10b8fd: b8 06 00 00 00 mov $0x6,%eax <== NOT EXECUTED 10b902: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b904: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *registered_major = major; 10b906: 89 13 mov %edx,(%ebx) <== NOT EXECUTED return rtems_io_initialize( major, 0, NULL ); 10b908: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) <== NOT EXECUTED 10b90f: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) <== NOT EXECUTED 10b916: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10b919: 59 pop %ecx <== NOT EXECUTED 10b91a: 5b pop %ebx <== NOT EXECUTED 10b91b: 5e pop %esi <== NOT EXECUTED 10b91c: 5f pop %edi <== NOT EXECUTED 10b91d: c9 leave <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10b91e: e9 f1 fd ff ff jmp 10b714 <== NOT EXECUTED 10b923: 90 nop <== NOT EXECUTED *registered_major = 0; /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 10b924: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); } 10b929: 5a pop %edx <== NOT EXECUTED 10b92a: 5b pop %ebx <== NOT EXECUTED 10b92b: 5e pop %esi <== NOT EXECUTED 10b92c: 5f pop %edi <== NOT EXECUTED 10b92d: c9 leave <== NOT EXECUTED 10b92e: c3 ret <== NOT EXECUTED 10b92f: 90 nop <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 10b930: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10b933: 8d 3c c5 00 00 00 00 lea 0x0(,%eax,8),%edi <== NOT EXECUTED 10b93a: 03 3d 88 19 12 00 add 0x121988,%edi <== NOT EXECUTED 10b940: 8b 07 mov (%edi),%eax <== NOT EXECUTED 10b942: 85 c0 test %eax,%eax <== NOT EXECUTED 10b944: 74 32 je 10b978 <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10b946: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED } 10b94b: 5a pop %edx <== NOT EXECUTED 10b94c: 5b pop %ebx <== NOT EXECUTED 10b94d: 5e pop %esi <== NOT EXECUTED 10b94e: 5f pop %edi <== NOT EXECUTED 10b94f: c9 leave <== NOT EXECUTED 10b950: c3 ret <== NOT EXECUTED 10b951: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10b954: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED } 10b959: 5a pop %edx <== NOT EXECUTED 10b95a: 5b pop %ebx <== NOT EXECUTED 10b95b: 5e pop %esi <== NOT EXECUTED 10b95c: 5f pop %edi <== NOT EXECUTED 10b95d: c9 leave <== NOT EXECUTED 10b95e: c3 ret <== NOT EXECUTED 10b95f: 90 nop <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !registered_major ) return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 10b960: 8b 7e 04 mov 0x4(%esi),%edi <== NOT EXECUTED 10b963: 85 ff test %edi,%edi <== NOT EXECUTED 10b965: 0f 85 4d ff ff ff jne 10b8b8 <== NOT EXECUTED 10b96b: 90 nop <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10b96c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED } 10b971: 5a pop %edx <== NOT EXECUTED 10b972: 5b pop %ebx <== NOT EXECUTED 10b973: 5e pop %esi <== NOT EXECUTED 10b974: 5f pop %edi <== NOT EXECUTED 10b975: c9 leave <== NOT EXECUTED 10b976: c3 ret <== NOT EXECUTED 10b977: 90 nop <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 10b978: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 10b97b: 85 c0 test %eax,%eax <== NOT EXECUTED 10b97d: 75 c7 jne 10b946 <== NOT EXECUTED 10b97f: e9 79 ff ff ff jmp 10b8fd <== NOT EXECUTED 0010b984 : */ rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { 10b984: 55 push %ebp <== NOT EXECUTED 10b985: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b987: 57 push %edi <== NOT EXECUTED 10b988: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b98b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( major < _IO_Number_of_drivers ) { 10b98e: 39 05 84 19 12 00 cmp %eax,0x121984 <== NOT EXECUTED 10b994: 77 0a ja 10b9a0 <== NOT EXECUTED 10b996: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED sizeof( rtems_driver_address_table ) ); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 10b99b: 5a pop %edx <== NOT EXECUTED 10b99c: 5f pop %edi <== NOT EXECUTED 10b99d: c9 leave <== NOT EXECUTED 10b99e: c3 ret <== NOT EXECUTED 10b99f: 90 nop <== NOT EXECUTED rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { if ( major < _IO_Number_of_drivers ) { memset( 10b9a0: 8d 3c 40 lea (%eax,%eax,2),%edi <== NOT EXECUTED 10b9a3: c1 e7 03 shl $0x3,%edi <== NOT EXECUTED 10b9a6: 03 3d 88 19 12 00 add 0x121988,%edi <== NOT EXECUTED 10b9ac: b9 18 00 00 00 mov $0x18,%ecx <== NOT EXECUTED 10b9b1: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b9b3: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 10b9b5: 31 c0 xor %eax,%eax <== NOT EXECUTED sizeof( rtems_driver_address_table ) ); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 10b9b7: 5a pop %edx <== NOT EXECUTED 10b9b8: 5f pop %edi <== NOT EXECUTED 10b9b9: c9 leave <== NOT EXECUTED 10b9ba: c3 ret <== NOT EXECUTED 0010ff40 : rtems_status_code rtems_io_write( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10ff40: 55 push %ebp <== NOT EXECUTED 10ff41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ff43: 56 push %esi <== NOT EXECUTED 10ff44: 53 push %ebx <== NOT EXECUTED 10ff45: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ff48: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10ff4b: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10ff4e: 39 0d a0 ed 11 00 cmp %ecx,0x11eda0 <== NOT EXECUTED 10ff54: 76 1e jbe 10ff74 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; 10ff56: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 10ff59: a1 a4 ed 11 00 mov 0x11eda4,%eax <== NOT EXECUTED 10ff5e: 8b 44 d0 10 mov 0x10(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10ff62: 85 c0 test %eax,%eax <== NOT EXECUTED 10ff64: 74 13 je 10ff79 <== NOT EXECUTED 10ff66: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10ff69: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10ff6c: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10ff6f: 5b pop %ebx <== NOT EXECUTED 10ff70: 5e pop %esi <== NOT EXECUTED 10ff71: 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; 10ff72: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10ff74: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 10ff79: 5b pop %ebx <== NOT EXECUTED 10ff7a: 5e pop %esi <== NOT EXECUTED 10ff7b: c9 leave <== NOT EXECUTED 10ff7c: c3 ret <== NOT EXECUTED 0010c8dc : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10c8dc: 55 push %ebp <== NOT EXECUTED 10c8dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c8df: 57 push %edi <== NOT EXECUTED 10c8e0: 56 push %esi <== NOT EXECUTED 10c8e1: 53 push %ebx <== NOT EXECUTED 10c8e2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10c8e5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c8e8: 85 c0 test %eax,%eax <== NOT EXECUTED 10c8ea: 74 47 je 10c933 <== NOT EXECUTED return; 10c8ec: 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 ] ) 10c8f1: 8b 04 bd 2c a5 12 00 mov 0x12a52c(,%edi,4),%eax <== NOT EXECUTED 10c8f8: 85 c0 test %eax,%eax <== NOT EXECUTED 10c8fa: 74 31 je 10c92d <== NOT EXECUTED continue; information = _Objects_Information_table[ api_index ][ 1 ]; 10c8fc: 8b 70 04 mov 0x4(%eax),%esi <== NOT EXECUTED if ( information ) { 10c8ff: 85 f6 test %esi,%esi <== NOT EXECUTED 10c901: 74 2a je 10c92d <== NOT EXECUTED for ( i=1 ; i <= information->maximum ; i++ ) { 10c903: 66 83 7e 10 00 cmpw $0x0,0x10(%esi) <== NOT EXECUTED 10c908: 74 23 je 10c92d <== NOT EXECUTED 10c90a: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10c90f: 90 nop <== NOT EXECUTED the_thread = (Thread_Control *)information->local_table[ i ]; 10c910: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED 10c913: 8b 04 98 mov (%eax,%ebx,4),%eax <== NOT EXECUTED if ( !the_thread ) 10c916: 85 c0 test %eax,%eax <== NOT EXECUTED 10c918: 74 0a je 10c924 <== NOT EXECUTED continue; (*routine)(the_thread); 10c91a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c91d: 50 push %eax <== NOT EXECUTED 10c91e: ff 55 08 call *0x8(%ebp) <== NOT EXECUTED 10c921: 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++ ) { 10c924: 43 inc %ebx <== NOT EXECUTED 10c925: 0f b7 46 10 movzwl 0x10(%esi),%eax <== NOT EXECUTED 10c929: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10c92b: 73 e3 jae 10c910 <== NOT EXECUTED if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10c92d: 47 inc %edi <== NOT EXECUTED if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 10c92e: 83 ff 05 cmp $0x5,%edi <== NOT EXECUTED 10c931: 75 be jne 10c8f1 <== NOT EXECUTED (*routine)(the_thread); } } } } 10c933: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c936: 5b pop %ebx <== NOT EXECUTED 10c937: 5e pop %esi <== NOT EXECUTED 10c938: 5f pop %edi <== NOT EXECUTED 10c939: c9 leave <== NOT EXECUTED 10c93a: c3 ret <== NOT EXECUTED 00112328 : Objects_Id id, const void *buffer, size_t size, uint32_t *count ) { 112328: 55 push %ebp <== NOT EXECUTED 112329: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11232b: 57 push %edi <== NOT EXECUTED 11232c: 56 push %esi <== NOT EXECUTED 11232d: 53 push %ebx <== NOT EXECUTED 11232e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 112331: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 112334: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 112337: 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 ) 11233a: 85 f6 test %esi,%esi <== NOT EXECUTED 11233c: 74 62 je 1123a0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !count ) 11233e: 85 db test %ebx,%ebx <== NOT EXECUTED 112340: 74 5e je 1123a0 <== 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, 112342: 51 push %ecx <== NOT EXECUTED 112343: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 112346: 50 push %eax <== NOT EXECUTED 112347: 57 push %edi <== NOT EXECUTED 112348: 68 20 5e 13 00 push $0x135e20 <== NOT EXECUTED 11234d: e8 4a 48 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 112352: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112355: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 112358: 85 d2 test %edx,%edx <== NOT EXECUTED 11235a: 74 10 je 11236c <== NOT EXECUTED 11235c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112361: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112364: 5b pop %ebx <== NOT EXECUTED 112365: 5e pop %esi <== NOT EXECUTED 112366: 5f pop %edi <== NOT EXECUTED 112367: c9 leave <== NOT EXECUTED 112368: c3 ret <== NOT EXECUTED 112369: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: core_status = _CORE_message_queue_Broadcast( 11236c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11236f: 53 push %ebx <== NOT EXECUTED 112370: 6a 00 push $0x0 <== NOT EXECUTED 112372: 57 push %edi <== NOT EXECUTED 112373: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 112376: 56 push %esi <== NOT EXECUTED 112377: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 11237a: 50 push %eax <== NOT EXECUTED 11237b: e8 78 31 00 00 call 1154f8 <_CORE_message_queue_Broadcast> <== NOT EXECUTED 112380: 89 c3 mov %eax,%ebx <== NOT EXECUTED NULL, #endif count ); _Thread_Enable_dispatch(); 112382: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 112385: e8 56 50 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED return 11238a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11238d: 53 push %ebx <== NOT EXECUTED 11238e: e8 5d 03 00 00 call 1126f0 <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 112393: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112396: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112399: 5b pop %ebx <== NOT EXECUTED 11239a: 5e pop %esi <== NOT EXECUTED 11239b: 5f pop %edi <== NOT EXECUTED 11239c: c9 leave <== NOT EXECUTED 11239d: c3 ret <== NOT EXECUTED 11239e: 66 90 xchg %ax,%ax <== NOT EXECUTED #endif count ); _Thread_Enable_dispatch(); return 1123a0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1123a5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1123a8: 5b pop %ebx <== NOT EXECUTED 1123a9: 5e pop %esi <== NOT EXECUTED 1123aa: 5f pop %edi <== NOT EXECUTED 1123ab: c9 leave <== NOT EXECUTED 1123ac: c3 ret <== NOT EXECUTED 0010ee6c : uint32_t count, size_t max_message_size, rtems_attribute attribute_set, Objects_Id *id ) { 10ee6c: 55 push %ebp <== NOT EXECUTED 10ee6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ee6f: 56 push %esi <== NOT EXECUTED 10ee70: 53 push %ebx <== NOT EXECUTED 10ee71: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ee74: 8b 75 08 mov 0x8(%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 ) ) 10ee77: 85 f6 test %esi,%esi <== NOT EXECUTED 10ee79: 74 31 je 10eeac <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 10ee7b: 8b 4d 18 mov 0x18(%ebp),%ecx <== NOT EXECUTED 10ee7e: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ee80: 0f 84 92 00 00 00 je 10ef18 <== NOT EXECUTED if ( (is_global = _Attributes_Is_global( attribute_set ) ) && !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) 10ee86: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10ee89: 85 d2 test %edx,%edx <== NOT EXECUTED 10ee8b: 74 13 je 10eea0 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 10ee8d: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10ee90: 85 c0 test %eax,%eax <== NOT EXECUTED 10ee92: 75 24 jne 10eeb8 <== NOT EXECUTED 10ee94: b8 08 00 00 00 mov $0x8,%eax <== NOT EXECUTED ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10ee99: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ee9c: 5b pop %ebx <== NOT EXECUTED 10ee9d: 5e pop %esi <== NOT EXECUTED 10ee9e: c9 leave <== NOT EXECUTED 10ee9f: c3 ret <== NOT EXECUTED if ( (is_global = _Attributes_Is_global( attribute_set ) ) && !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) 10eea0: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10eea5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10eea8: 5b pop %ebx <== NOT EXECUTED 10eea9: 5e pop %esi <== NOT EXECUTED 10eeaa: c9 leave <== NOT EXECUTED 10eeab: c3 ret <== NOT EXECUTED CORE_message_queue_Attributes the_msgq_attributes; #if defined(RTEMS_MULTIPROCESSING) bool is_global; #endif if ( !rtems_is_name_valid( name ) ) 10eeac: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10eeb1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10eeb4: 5b pop %ebx <== NOT EXECUTED 10eeb5: 5e pop %esi <== NOT EXECUTED 10eeb6: c9 leave <== NOT EXECUTED 10eeb7: c3 ret <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10eeb8: a1 18 12 16 00 mov 0x161218,%eax <== NOT EXECUTED 10eebd: 40 inc %eax <== NOT EXECUTED 10eebe: a3 18 12 16 00 mov %eax,0x161218 <== NOT EXECUTED #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); 10eec3: e8 f4 6a 01 00 call 1259bc <_Message_queue_Allocate> <== NOT EXECUTED 10eec8: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !the_message_queue ) { 10eeca: 85 c0 test %eax,%eax <== NOT EXECUTED 10eecc: 74 7a je 10ef48 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_message_queue->attribute_set = attribute_set; 10eece: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10eed1: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED if (_Attributes_Is_priority( attribute_set ) ) the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 10eed4: a8 04 test $0x4,%al <== NOT EXECUTED 10eed6: 0f 95 c0 setne %al <== NOT EXECUTED 10eed9: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10eedc: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( ! _CORE_message_queue_Initialize( 10eedf: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10eee2: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10eee5: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10eee8: 50 push %eax <== NOT EXECUTED 10eee9: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 10eeec: 50 push %eax <== NOT EXECUTED 10eeed: e8 ce 0e 00 00 call 10fdc0 <_CORE_message_queue_Initialize> <== NOT EXECUTED 10eef2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eef5: 84 c0 test %al,%al <== NOT EXECUTED 10eef7: 75 2b jne 10ef24 <== 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, 10eef9: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10eefc: 53 push %ebx <== NOT EXECUTED 10eefd: 68 a0 16 16 00 push $0x1616a0 <== NOT EXECUTED 10ef02: e8 a5 1c 00 00 call 110bac <_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(); 10ef07: e8 c8 27 00 00 call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ef0c: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 10ef11: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ef14: eb 83 jmp 10ee99 <== NOT EXECUTED 10ef16: 66 90 xchg %ax,%ax <== NOT EXECUTED #endif if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 10ef18: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10ef1d: e9 77 ff ff ff jmp 10ee99 <== NOT EXECUTED 10ef22: 66 90 xchg %ax,%ax <== NOT EXECUTED 10ef24: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10ef27: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10ef2a: a1 bc 16 16 00 mov 0x1616bc,%eax <== NOT EXECUTED 10ef2f: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10ef32: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 10ef35: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10ef38: 89 08 mov %ecx,(%eax) <== NOT EXECUTED name, 0 ); #endif _Thread_Enable_dispatch(); 10ef3a: e8 95 27 00 00 call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ef3f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ef41: e9 53 ff ff ff jmp 10ee99 <== NOT EXECUTED 10ef46: 66 90 xchg %ax,%ax <== NOT EXECUTED _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); if ( !the_message_queue ) { _Thread_Enable_dispatch(); 10ef48: e8 87 27 00 00 call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ef4d: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10ef52: e9 42 ff ff ff jmp 10ee99 <== NOT EXECUTED 001158dc : */ rtems_status_code rtems_message_queue_delete( Objects_Id id ) { 1158dc: 55 push %ebp <== NOT EXECUTED 1158dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1158df: 53 push %ebx <== NOT EXECUTED 1158e0: 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, 1158e3: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1158e6: 50 push %eax <== NOT EXECUTED 1158e7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1158ea: 68 80 cd 12 00 push $0x12cd80 <== NOT EXECUTED 1158ef: e8 7c af ff ff call 110870 <_Objects_Get> <== NOT EXECUTED 1158f4: 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 ) { 1158f6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1158f9: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 1158fc: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1158fe: 75 3c jne 11593c <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, 115900: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 115903: 50 push %eax <== NOT EXECUTED 115904: 68 80 cd 12 00 push $0x12cd80 <== NOT EXECUTED 115909: e8 ee aa ff ff call 1103fc <_Objects_Close> <== NOT EXECUTED &the_message_queue->Object ); _CORE_message_queue_Close( 11590e: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 115911: 6a 05 push $0x5 <== NOT EXECUTED 115913: 6a 00 push $0x0 <== NOT EXECUTED 115915: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 115918: 50 push %eax <== NOT EXECUTED 115919: e8 ce 04 00 00 call 115dec <_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, 11591e: 58 pop %eax <== NOT EXECUTED 11591f: 5a pop %edx <== NOT EXECUTED 115920: 53 push %ebx <== NOT EXECUTED 115921: 68 80 cd 12 00 push $0x12cd80 <== NOT EXECUTED 115926: e8 11 ae ff ff call 11073c <_Objects_Free> <== NOT EXECUTED 0, /* Not used */ 0 ); } #endif _Thread_Enable_dispatch(); 11592b: e8 84 b7 ff ff call 1110b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 115930: 31 c0 xor %eax,%eax <== NOT EXECUTED 115932: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 115935: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 115938: c9 leave <== NOT EXECUTED 115939: c3 ret <== NOT EXECUTED 11593a: 66 90 xchg %ax,%ax <== NOT EXECUTED { register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 11593c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 115941: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 115944: c9 leave <== NOT EXECUTED 115945: c3 ret <== NOT EXECUTED 00112508 : rtems_status_code rtems_message_queue_flush( Objects_Id id, uint32_t *count ) { 112508: 55 push %ebp <== NOT EXECUTED 112509: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11250b: 53 push %ebx <== NOT EXECUTED 11250c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 11250f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 112512: 85 db test %ebx,%ebx <== NOT EXECUTED 112514: 74 46 je 11255c <== 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, 112516: 51 push %ecx <== NOT EXECUTED 112517: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 11251a: 50 push %eax <== NOT EXECUTED 11251b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11251e: 68 20 5e 13 00 push $0x135e20 <== NOT EXECUTED 112523: e8 74 46 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 112528: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11252b: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 11252e: 85 d2 test %edx,%edx <== NOT EXECUTED 112530: 74 0a je 11253c <== NOT EXECUTED 112532: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112537: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11253a: c9 leave <== NOT EXECUTED 11253b: c3 ret <== NOT EXECUTED the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: *count = _CORE_message_queue_Flush( &the_message_queue->message_queue ); 11253c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11253f: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 112542: 50 push %eax <== NOT EXECUTED 112543: e8 68 30 00 00 call 1155b0 <_CORE_message_queue_Flush> <== NOT EXECUTED 112548: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 11254a: e8 91 4e 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 11254f: 31 c0 xor %eax,%eax <== NOT EXECUTED 112551: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112554: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112557: c9 leave <== NOT EXECUTED 112558: c3 ret <== NOT EXECUTED 112559: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 11255c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112561: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112564: c9 leave <== NOT EXECUTED 112565: c3 ret <== NOT EXECUTED 00112568 : rtems_status_code rtems_message_queue_get_number_pending( Objects_Id id, uint32_t *count ) { 112568: 55 push %ebp <== NOT EXECUTED 112569: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11256b: 53 push %ebx <== NOT EXECUTED 11256c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 11256f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 112572: 85 db test %ebx,%ebx <== NOT EXECUTED 112574: 74 3a je 1125b0 <== NOT EXECUTED 112576: 51 push %ecx <== NOT EXECUTED 112577: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 11257a: 50 push %eax <== NOT EXECUTED 11257b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11257e: 68 20 5e 13 00 push $0x135e20 <== NOT EXECUTED 112583: e8 14 46 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 112588: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11258b: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 11258e: 85 d2 test %edx,%edx <== NOT EXECUTED 112590: 74 0a je 11259c <== NOT EXECUTED 112592: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112597: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11259a: c9 leave <== NOT EXECUTED 11259b: c3 ret <== NOT EXECUTED the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: *count = the_message_queue->message_queue.number_of_pending_messages; 11259c: 8b 40 5c mov 0x5c(%eax),%eax <== NOT EXECUTED 11259f: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 1125a1: e8 3a 4e 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 1125a6: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1125a8: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1125ab: c9 leave <== NOT EXECUTED 1125ac: c3 ret <== NOT EXECUTED 1125ad: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 1125b0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1125b5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1125b8: c9 leave <== NOT EXECUTED 1125b9: c3 ret <== NOT EXECUTED 0010a07c : rtems_status_code rtems_message_queue_ident( rtems_name name, uint32_t node, Objects_Id *id ) { 10a07c: 55 push %ebp <== NOT EXECUTED 10a07d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a07f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 10a082: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10a085: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a088: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a08b: 68 20 ed 11 00 push $0x11ed20 <== NOT EXECUTED 10a090: e8 27 1b 00 00 call 10bbbc <_Objects_Name_to_id_u32> <== NOT EXECUTED 10a095: 8b 04 85 ac 85 11 00 mov 0x1185ac(,%eax,4),%eax <== NOT EXECUTED node, id ); return _Status_Object_name_errors_to_status[ status ]; } 10a09c: c9 leave <== NOT EXECUTED 10a09d: c3 ret <== NOT EXECUTED 00115948 : void *buffer, size_t *size, rtems_option option_set, rtems_interval timeout ) { 115948: 55 push %ebp <== NOT EXECUTED 115949: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11594b: 57 push %edi <== NOT EXECUTED 11594c: 56 push %esi <== NOT EXECUTED 11594d: 53 push %ebx <== NOT EXECUTED 11594e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 115951: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 115954: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 115957: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; bool wait; if ( !buffer ) 11595a: 85 ff test %edi,%edi <== NOT EXECUTED 11595c: 74 6e je 1159cc <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !size ) 11595e: 85 f6 test %esi,%esi <== NOT EXECUTED 115960: 74 6a je 1159cc <== 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, 115962: 51 push %ecx <== NOT EXECUTED 115963: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 115966: 50 push %eax <== NOT EXECUTED 115967: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11596a: 68 80 cd 12 00 push $0x12cd80 <== NOT EXECUTED 11596f: e8 fc ae ff ff call 110870 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 115974: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115977: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 11597a: 85 d2 test %edx,%edx <== NOT EXECUTED 11597c: 75 3e jne 1159bc <== NOT EXECUTED if ( _Options_Is_no_wait( option_set ) ) wait = false; else wait = true; _CORE_message_queue_Seize( 11597e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 115981: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 115984: 83 f3 01 xor $0x1,%ebx <== NOT EXECUTED 115987: 83 e3 01 and $0x1,%ebx <== NOT EXECUTED 11598a: 53 push %ebx <== NOT EXECUTED 11598b: 56 push %esi <== NOT EXECUTED 11598c: 57 push %edi <== NOT EXECUTED 11598d: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 115990: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 115993: 50 push %eax <== NOT EXECUTED 115994: e8 b7 05 00 00 call 115f50 <_CORE_message_queue_Seize> <== NOT EXECUTED buffer, size, wait, timeout ); _Thread_Enable_dispatch(); 115999: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 11599c: e8 13 b7 ff ff call 1110b4 <_Thread_Enable_dispatch> <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code( 1159a1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1159a4: a1 9c ca 12 00 mov 0x12ca9c,%eax <== NOT EXECUTED 1159a9: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 1159ac: e8 63 92 ff ff call 10ec14 <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 1159b1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1159b4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1159b7: 5b pop %ebx <== NOT EXECUTED 1159b8: 5e pop %esi <== NOT EXECUTED 1159b9: 5f pop %edi <== NOT EXECUTED 1159ba: c9 leave <== NOT EXECUTED 1159bb: c3 ret <== NOT EXECUTED if ( !size ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 1159bc: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1159c1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1159c4: 5b pop %ebx <== NOT EXECUTED 1159c5: 5e pop %esi <== NOT EXECUTED 1159c6: 5f pop %edi <== NOT EXECUTED 1159c7: c9 leave <== NOT EXECUTED 1159c8: c3 ret <== NOT EXECUTED 1159c9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 1159cc: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1159d1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1159d4: 5b pop %ebx <== NOT EXECUTED 1159d5: 5e pop %esi <== NOT EXECUTED 1159d6: 5f pop %edi <== NOT EXECUTED 1159d7: c9 leave <== NOT EXECUTED 1159d8: c3 ret <== NOT EXECUTED 0010a0a0 : rtems_status_code rtems_message_queue_send( Objects_Id id, const void *buffer, size_t size ) { 10a0a0: 55 push %ebp <== NOT EXECUTED 10a0a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a0a3: 56 push %esi <== NOT EXECUTED 10a0a4: 53 push %ebx <== NOT EXECUTED 10a0a5: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10a0a8: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10a0ab: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 10a0ae: 85 db test %ebx,%ebx <== NOT EXECUTED 10a0b0: 74 5e je 10a110 <== 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, 10a0b2: 51 push %ecx <== NOT EXECUTED 10a0b3: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10a0b6: 50 push %eax <== NOT EXECUTED 10a0b7: 56 push %esi <== NOT EXECUTED 10a0b8: 68 20 ed 11 00 push $0x11ed20 <== NOT EXECUTED 10a0bd: e8 a2 19 00 00 call 10ba64 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 10a0c2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a0c5: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 10a0c8: 85 d2 test %edx,%edx <== NOT EXECUTED 10a0ca: 74 0c je 10a0d8 <== NOT EXECUTED 10a0cc: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a0d1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a0d4: 5b pop %ebx <== NOT EXECUTED 10a0d5: 5e pop %esi <== NOT EXECUTED 10a0d6: c9 leave <== NOT EXECUTED 10a0d7: c3 ret <== 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 10a0d8: 6a 00 push $0x0 <== NOT EXECUTED 10a0da: 6a 00 push $0x0 <== NOT EXECUTED 10a0dc: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 10a0e1: 6a 00 push $0x0 <== NOT EXECUTED 10a0e3: 56 push %esi <== NOT EXECUTED 10a0e4: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10a0e7: 53 push %ebx <== NOT EXECUTED 10a0e8: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 10a0eb: 50 push %eax <== NOT EXECUTED 10a0ec: e8 93 0c 00 00 call 10ad84 <_CORE_message_queue_Submit> <== NOT EXECUTED 10a0f1: 89 c3 mov %eax,%ebx <== NOT EXECUTED MESSAGE_QUEUE_MP_HANDLER, FALSE, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 10a0f3: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10a0f6: e8 ad 21 00 00 call 10c2a8 <_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); 10a0fb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a0fe: 53 push %ebx <== NOT EXECUTED 10a0ff: e8 18 00 00 00 call 10a11c <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 10a104: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a107: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a10a: 5b pop %ebx <== NOT EXECUTED 10a10b: 5e pop %esi <== NOT EXECUTED 10a10c: c9 leave <== NOT EXECUTED 10a10d: c3 ret <== NOT EXECUTED 10a10e: 66 90 xchg %ax,%ax <== NOT EXECUTED { register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 10a110: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a115: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a118: 5b pop %ebx <== NOT EXECUTED 10a119: 5e pop %esi <== NOT EXECUTED 10a11a: c9 leave <== NOT EXECUTED 10a11b: c3 ret <== NOT EXECUTED 00112700 : rtems_status_code rtems_message_queue_urgent( Objects_Id id, const void *buffer, size_t size ) { 112700: 55 push %ebp <== NOT EXECUTED 112701: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112703: 56 push %esi <== NOT EXECUTED 112704: 53 push %ebx <== NOT EXECUTED 112705: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 112708: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 11270b: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 11270e: 85 db test %ebx,%ebx <== NOT EXECUTED 112710: 74 5e je 112770 <== 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, 112712: 51 push %ecx <== NOT EXECUTED 112713: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 112716: 50 push %eax <== NOT EXECUTED 112717: 56 push %esi <== NOT EXECUTED 112718: 68 20 5e 13 00 push $0x135e20 <== NOT EXECUTED 11271d: e8 7a 44 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 112722: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112725: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 112728: 85 d2 test %edx,%edx <== NOT EXECUTED 11272a: 74 0c je 112738 <== NOT EXECUTED 11272c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112731: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 112734: 5b pop %ebx <== NOT EXECUTED 112735: 5e pop %esi <== NOT EXECUTED 112736: c9 leave <== NOT EXECUTED 112737: c3 ret <== NOT EXECUTED size_t size 112738: 6a 00 push $0x0 <== NOT EXECUTED 11273a: 6a 00 push $0x0 <== NOT EXECUTED 11273c: 68 00 00 00 80 push $0x80000000 <== NOT EXECUTED 112741: 6a 00 push $0x0 <== NOT EXECUTED 112743: 56 push %esi <== NOT EXECUTED 112744: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 112747: 53 push %ebx <== NOT EXECUTED 112748: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 11274b: 50 push %eax <== NOT EXECUTED 11274c: e8 a7 30 00 00 call 1157f8 <_CORE_message_queue_Submit> <== NOT EXECUTED 112751: 89 c3 mov %eax,%ebx <== NOT EXECUTED id, MESSAGE_QUEUE_MP_HANDLER, FALSE, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 112753: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 112756: e8 85 4c 00 00 call 1173e0 <_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); 11275b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11275e: 53 push %ebx <== NOT EXECUTED 11275f: e8 8c ff ff ff call 1126f0 <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 112764: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112767: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11276a: 5b pop %ebx <== NOT EXECUTED 11276b: 5e pop %esi <== NOT EXECUTED 11276c: c9 leave <== NOT EXECUTED 11276d: c3 ret <== NOT EXECUTED 11276e: 66 90 xchg %ax,%ax <== NOT EXECUTED { register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 112770: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112775: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 112778: 5b pop %ebx <== NOT EXECUTED 112779: 5e pop %esi <== NOT EXECUTED 11277a: c9 leave <== NOT EXECUTED 11277b: c3 ret <== NOT EXECUTED 0010b6bc : #include int rtems_object_api_maximum_class( uint32_t api ) { 10b6bc: 55 push %ebp <== NOT EXECUTED 10b6bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_API_maximum_class(api); } 10b6bf: c9 leave <== NOT EXECUTED int rtems_object_api_maximum_class( uint32_t api ) { return _Objects_API_maximum_class(api); 10b6c0: e9 e7 16 00 00 jmp 10cdac <_Objects_API_maximum_class> <== NOT EXECUTED 0010b6c8 : #include uint32_t rtems_object_api_minimum_class( uint32_t api ) { 10b6c8: 55 push %ebp <== NOT EXECUTED 10b6c9: 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. 10b6cb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b6ce: 48 dec %eax <== NOT EXECUTED 10b6cf: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10b6d2: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10b6d4: 83 e0 02 and $0x2,%eax <== NOT EXECUTED 10b6d7: 48 dec %eax <== NOT EXECUTED if ( _Objects_Is_api_valid( api ) ) return 1; return -1; } 10b6d8: c9 leave <== NOT EXECUTED 10b6d9: c3 ret <== NOT EXECUTED 0010b6dc : const char *rtems_object_get_api_class_name( uint32_t the_api, uint32_t the_class ) { 10b6dc: 55 push %ebp <== NOT EXECUTED 10b6dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b6df: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) 10b6e2: 83 7d 08 01 cmpl $0x1,0x8(%ebp) <== NOT EXECUTED 10b6e6: 74 2c je 10b714 <== NOT EXECUTED api_assoc = rtems_object_api_internal_assoc; else if ( the_api == OBJECTS_CLASSIC_API ) 10b6e8: 83 7d 08 02 cmpl $0x2,0x8(%ebp) <== NOT EXECUTED 10b6ec: 74 0a je 10b6f8 <== NOT EXECUTED 10b6ee: b8 d0 c4 11 00 mov $0x11c4d0,%eax <== NOT EXECUTED return "BAD API"; class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class ); if ( class_assoc ) return class_assoc->name; return "BAD CLASS"; } 10b6f3: c9 leave <== NOT EXECUTED 10b6f4: c3 ret <== NOT EXECUTED 10b6f5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) api_assoc = rtems_object_api_internal_assoc; else if ( the_api == OBJECTS_CLASSIC_API ) 10b6f8: b8 e0 04 12 00 mov $0x1204e0,%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 ); 10b6fd: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b700: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b703: 50 push %eax <== NOT EXECUTED 10b704: e8 17 47 00 00 call 10fe20 <== NOT EXECUTED if ( class_assoc ) 10b709: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b70c: 85 c0 test %eax,%eax <== NOT EXECUTED 10b70e: 74 0c je 10b71c <== NOT EXECUTED return class_assoc->name; 10b710: 8b 00 mov (%eax),%eax <== NOT EXECUTED return "BAD CLASS"; } 10b712: c9 leave <== NOT EXECUTED 10b713: c3 ret <== NOT EXECUTED ) { const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) 10b714: b8 c0 04 12 00 mov $0x1204c0,%eax <== NOT EXECUTED 10b719: eb e2 jmp 10b6fd <== NOT EXECUTED 10b71b: 90 nop <== NOT EXECUTED api_assoc = rtems_object_api_itron_assoc; #endif else return "BAD API"; class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class ); if ( class_assoc ) 10b71c: b8 d8 c4 11 00 mov $0x11c4d8,%eax <== NOT EXECUTED return class_assoc->name; return "BAD CLASS"; } 10b721: c9 leave <== NOT EXECUTED 10b722: c3 ret <== NOT EXECUTED 0010b724 : }; const char *rtems_object_get_api_name( uint32_t api ) { 10b724: 55 push %ebp <== NOT EXECUTED 10b725: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b727: 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 ); 10b72a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b72d: 68 60 05 12 00 push $0x120560 <== NOT EXECUTED 10b732: e8 e9 46 00 00 call 10fe20 <== NOT EXECUTED if ( api_assoc ) 10b737: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b73a: 85 c0 test %eax,%eax <== NOT EXECUTED 10b73c: 74 06 je 10b744 <== NOT EXECUTED return api_assoc->name; 10b73e: 8b 00 mov (%eax),%eax <== NOT EXECUTED return "BAD CLASS"; } 10b740: c9 leave <== NOT EXECUTED 10b741: c3 ret <== NOT EXECUTED 10b742: 66 90 xchg %ax,%ax <== NOT EXECUTED ) { const rtems_assoc_t *api_assoc; api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api ); if ( api_assoc ) 10b744: b8 d8 c4 11 00 mov $0x11c4d8,%eax <== NOT EXECUTED return api_assoc->name; return "BAD CLASS"; } 10b749: c9 leave <== NOT EXECUTED 10b74a: c3 ret <== NOT EXECUTED 0010b78c : rtems_status_code rtems_object_get_class_information( uint32_t the_api, uint32_t the_class, rtems_object_api_class_information *info ) { 10b78c: 55 push %ebp <== NOT EXECUTED 10b78d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b78f: 56 push %esi <== NOT EXECUTED 10b790: 53 push %ebx <== NOT EXECUTED 10b791: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED uint32_t i; /* * Validate parameters and look up information structure. */ if ( !info ) 10b794: 85 f6 test %esi,%esi <== NOT EXECUTED 10b796: 74 58 je 10b7f0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); 10b798: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b79b: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b79e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b7a1: e8 22 1a 00 00 call 10d1c8 <_Objects_Get_information> <== NOT EXECUTED 10b7a6: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !obj_info ) 10b7a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b7ab: 85 c0 test %eax,%eax <== NOT EXECUTED 10b7ad: 74 4d je 10b7fc <== NOT EXECUTED return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 10b7af: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10b7b2: 89 06 mov %eax,(%esi) <== NOT EXECUTED info->maximum_id = obj_info->maximum_id; 10b7b4: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10b7b7: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED info->auto_extend = obj_info->auto_extend; 10b7ba: 8a 42 12 mov 0x12(%edx),%al <== NOT EXECUTED 10b7bd: 88 46 0c mov %al,0xc(%esi) <== NOT EXECUTED info->maximum = obj_info->maximum; 10b7c0: 0f b7 42 10 movzwl 0x10(%edx),%eax <== NOT EXECUTED 10b7c4: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 10b7c7: 85 c0 test %eax,%eax <== NOT EXECUTED 10b7c9: 74 3d je 10b808 <== NOT EXECUTED 10b7cb: 8b 5a 1c mov 0x1c(%edx),%ebx <== NOT EXECUTED 10b7ce: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10b7d0: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10b7d5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !obj_info->local_table[i] ) unallocated++; 10b7d8: 83 3c 93 01 cmpl $0x1,(%ebx,%edx,4) <== NOT EXECUTED 10b7dc: 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++ ) 10b7df: 42 inc %edx <== NOT EXECUTED 10b7e0: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10b7e2: 73 f4 jae 10b7d8 <== NOT EXECUTED if ( !obj_info->local_table[i] ) unallocated++; info->unallocated = unallocated; 10b7e4: 89 4e 10 mov %ecx,0x10(%esi) <== NOT EXECUTED 10b7e7: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10b7e9: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b7ec: 5b pop %ebx <== NOT EXECUTED 10b7ed: 5e pop %esi <== NOT EXECUTED 10b7ee: c9 leave <== NOT EXECUTED 10b7ef: c3 ret <== NOT EXECUTED uint32_t i; /* * Validate parameters and look up information structure. */ if ( !info ) 10b7f0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED unallocated++; info->unallocated = unallocated; return RTEMS_SUCCESSFUL; } 10b7f5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b7f8: 5b pop %ebx <== NOT EXECUTED 10b7f9: 5e pop %esi <== NOT EXECUTED 10b7fa: c9 leave <== NOT EXECUTED 10b7fb: c3 ret <== NOT EXECUTED */ if ( !info ) return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); if ( !obj_info ) 10b7fc: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED unallocated++; info->unallocated = unallocated; return RTEMS_SUCCESSFUL; } 10b801: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b804: 5b pop %ebx <== NOT EXECUTED 10b805: 5e pop %esi <== NOT EXECUTED 10b806: c9 leave <== NOT EXECUTED 10b807: c3 ret <== 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++ ) 10b808: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10b80a: eb d8 jmp 10b7e4 <== NOT EXECUTED 0010b008 : rtems_status_code rtems_object_get_classic_name( rtems_id id, rtems_name *name ) { 10b008: 55 push %ebp <== NOT EXECUTED 10b009: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b00b: 53 push %ebx <== NOT EXECUTED 10b00c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10b00f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; Objects_Name name_u; if ( !name ) 10b012: 85 db test %ebx,%ebx <== NOT EXECUTED 10b014: 74 26 je 10b03c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; status = _Objects_Id_to_name( id, &name_u ); 10b016: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b019: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10b01c: 50 push %eax <== NOT EXECUTED 10b01d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b020: e8 d3 1a 00 00 call 10caf8 <_Objects_Id_to_name> <== NOT EXECUTED *name = name_u.name_u32; 10b025: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10b028: 89 13 mov %edx,(%ebx) <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; 10b02a: 8b 04 85 ac b4 11 00 mov 0x11b4ac(,%eax,4),%eax <== NOT EXECUTED 10b031: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b034: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b037: c9 leave <== NOT EXECUTED 10b038: c3 ret <== NOT EXECUTED 10b039: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { Objects_Name_or_id_lookup_errors status; Objects_Name name_u; if ( !name ) 10b03c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED status = _Objects_Id_to_name( id, &name_u ); *name = name_u.name_u32; return _Status_Object_name_errors_to_status[ status ]; } 10b041: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b044: c9 leave <== NOT EXECUTED 10b045: c3 ret <== NOT EXECUTED 00115a50 : char *rtems_object_get_name( Objects_Id id, size_t length, char *name ) { 115a50: 55 push %ebp <== NOT EXECUTED 115a51: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_Get_name_as_string( id, length, name ); } 115a53: c9 leave <== NOT EXECUTED Objects_Id id, size_t length, char *name ) { return _Objects_Get_name_as_string( id, length, name ); 115a54: e9 9f 09 00 00 jmp 1163f8 <_Objects_Get_name_as_string> <== NOT EXECUTED 0010b818 : #include #include #undef rtems_object_id_api_maximum uint32_t rtems_object_id_api_maximum(void) { 10b818: 55 push %ebp <== NOT EXECUTED 10b819: 89 e5 mov %esp,%ebp <== NOT EXECUTED return OBJECTS_ITRON_API; } 10b81b: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10b820: c9 leave <== NOT EXECUTED 10b821: c3 ret <== NOT EXECUTED 0010b824 : #include #include #undef rtems_object_id_api_minimum uint32_t rtems_object_id_api_minimum(void) { 10b824: 55 push %ebp <== NOT EXECUTED 10b825: 89 e5 mov %esp,%ebp <== NOT EXECUTED return OBJECTS_INTERNAL_API; } 10b827: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10b82c: c9 leave <== NOT EXECUTED 10b82d: c3 ret <== NOT EXECUTED 0010b830 : #undef rtems_object_id_get_api uint32_t rtems_object_id_get_api( rtems_id id ) { 10b830: 55 push %ebp <== NOT EXECUTED 10b831: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b833: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b836: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10b839: 83 e0 07 and $0x7,%eax <== NOT EXECUTED return _Objects_Get_API( id ); } 10b83c: c9 leave <== NOT EXECUTED 10b83d: c3 ret <== NOT EXECUTED 0010b840 : #undef rtems_object_id_get_class uint32_t rtems_object_id_get_class( rtems_id id ) { 10b840: 55 push %ebp <== NOT EXECUTED 10b841: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b843: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b846: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED return _Objects_Get_class( id ); } 10b849: c9 leave <== NOT EXECUTED 10b84a: c3 ret <== NOT EXECUTED 0010b84c : #undef rtems_object_id_get_index uint32_t rtems_object_id_get_index( rtems_id id ) { 10b84c: 55 push %ebp <== NOT EXECUTED 10b84d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b84f: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED return _Objects_Get_index( id ); } 10b853: c9 leave <== NOT EXECUTED 10b854: c3 ret <== NOT EXECUTED 0010b858 : #undef rtems_object_id_get_node uint32_t rtems_object_id_get_node( rtems_id id ) { 10b858: 55 push %ebp <== NOT EXECUTED 10b859: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b85b: 0f b6 45 0a movzbl 0xa(%ebp),%eax <== NOT EXECUTED return _Objects_Get_node( id ); } 10b85f: c9 leave <== NOT EXECUTED 10b860: c3 ret <== NOT EXECUTED 0010b864 : */ rtems_status_code rtems_object_set_name( rtems_id id, const char *name ) { 10b864: 55 push %ebp <== NOT EXECUTED 10b865: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b867: 57 push %edi <== NOT EXECUTED 10b868: 56 push %esi <== NOT EXECUTED 10b869: 53 push %ebx <== NOT EXECUTED 10b86a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10b86d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b870: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 10b873: 85 ff test %edi,%edi <== NOT EXECUTED 10b875: 74 65 je 10b8dc <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10b877: 85 c0 test %eax,%eax <== NOT EXECUTED 10b879: 74 45 je 10b8c0 <== NOT EXECUTED 10b87b: 89 c3 mov %eax,%ebx <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 10b87d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b880: 53 push %ebx <== NOT EXECUTED 10b881: e8 22 19 00 00 call 10d1a8 <_Objects_Get_information_id> <== NOT EXECUTED 10b886: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( !information ) 10b888: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b88b: 85 c0 test %eax,%eax <== NOT EXECUTED 10b88d: 74 3d je 10b8cc <== NOT EXECUTED return RTEMS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &location ); 10b88f: 50 push %eax <== NOT EXECUTED 10b890: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b893: 50 push %eax <== NOT EXECUTED 10b894: 53 push %ebx <== NOT EXECUTED 10b895: 56 push %esi <== NOT EXECUTED 10b896: e8 cd 1a 00 00 call 10d368 <_Objects_Get> <== NOT EXECUTED switch ( location ) { 10b89b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b89e: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10b8a1: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b8a3: 75 27 jne 10b8cc <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Set_name( information, the_object, name ); 10b8a5: 52 push %edx <== NOT EXECUTED 10b8a6: 57 push %edi <== NOT EXECUTED 10b8a7: 50 push %eax <== NOT EXECUTED 10b8a8: 56 push %esi <== NOT EXECUTED 10b8a9: e8 32 1d 00 00 call 10d5e0 <_Objects_Set_name> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b8ae: e8 81 24 00 00 call 10dd34 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b8b3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b8b5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b8b8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b8bb: 5b pop %ebx <== NOT EXECUTED 10b8bc: 5e pop %esi <== NOT EXECUTED 10b8bd: 5f pop %edi <== NOT EXECUTED 10b8be: c9 leave <== NOT EXECUTED 10b8bf: c3 ret <== NOT EXECUTED Objects_Id tmpId; if ( !name ) return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10b8c0: a1 5c 28 12 00 mov 0x12285c,%eax <== NOT EXECUTED 10b8c5: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED 10b8c8: eb b3 jmp 10b87d <== NOT EXECUTED 10b8ca: 66 90 xchg %ax,%ax <== NOT EXECUTED switch ( location ) { case OBJECTS_LOCAL: _Objects_Set_name( information, the_object, name ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 10b8cc: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b8d1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b8d4: 5b pop %ebx <== NOT EXECUTED 10b8d5: 5e pop %esi <== NOT EXECUTED 10b8d6: 5f pop %edi <== NOT EXECUTED 10b8d7: c9 leave <== NOT EXECUTED 10b8d8: c3 ret <== NOT EXECUTED 10b8d9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 10b8dc: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10b8e1: eb d5 jmp 10b8b8 <== NOT EXECUTED 0011277c : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, Objects_Id *id ) { 11277c: 55 push %ebp <== NOT EXECUTED 11277d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11277f: 56 push %esi <== NOT EXECUTED 112780: 53 push %ebx <== NOT EXECUTED 112781: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 112784: 85 f6 test %esi,%esi <== NOT EXECUTED 112786: 74 48 je 1127d0 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !starting_address ) 112788: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 11278b: 85 db test %ebx,%ebx <== NOT EXECUTED 11278d: 74 27 je 1127b6 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !id ) 11278f: 8b 4d 1c mov 0x1c(%ebp),%ecx <== NOT EXECUTED 112792: 85 c9 test %ecx,%ecx <== NOT EXECUTED 112794: 74 20 je 1127b6 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 112796: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 112799: 85 d2 test %edx,%edx <== NOT EXECUTED 11279b: 74 27 je 1127c4 <== NOT EXECUTED 11279d: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1127a0: 85 c0 test %eax,%eax <== NOT EXECUTED 1127a2: 74 20 je 1127c4 <== NOT EXECUTED 1127a4: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1127a7: 39 45 10 cmp %eax,0x10(%ebp) <== NOT EXECUTED 1127aa: 72 18 jb 1127c4 <== NOT EXECUTED 1127ac: a8 03 test $0x3,%al <== NOT EXECUTED 1127ae: 75 14 jne 1127c4 <== NOT EXECUTED !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 1127b0: f6 45 0c 03 testb $0x3,0xc(%ebp) <== NOT EXECUTED 1127b4: 74 26 je 1127dc <== NOT EXECUTED 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 1127b6: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED } 1127bb: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1127be: 5b pop %ebx <== NOT EXECUTED 1127bf: 5e pop %esi <== NOT EXECUTED 1127c0: c9 leave <== NOT EXECUTED 1127c1: c3 ret <== NOT EXECUTED 1127c2: 66 90 xchg %ax,%ax <== NOT EXECUTED 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 1127c4: b8 08 00 00 00 mov $0x8,%eax <== NOT EXECUTED } 1127c9: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1127cc: 5b pop %ebx <== NOT EXECUTED 1127cd: 5e pop %esi <== NOT EXECUTED 1127ce: c9 leave <== NOT EXECUTED 1127cf: c3 ret <== NOT EXECUTED Objects_Id *id ) { register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 1127d0: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1127d5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1127d8: 5b pop %ebx <== NOT EXECUTED 1127d9: 5e pop %esi <== NOT EXECUTED 1127da: c9 leave <== NOT EXECUTED 1127db: c3 ret <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1127dc: a1 f8 5a 13 00 mov 0x135af8,%eax <== NOT EXECUTED 1127e1: 40 inc %eax <== NOT EXECUTED 1127e2: a3 f8 5a 13 00 mov %eax,0x135af8 <== 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 1127e7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1127ea: 68 00 59 13 00 push $0x135900 <== NOT EXECUTED 1127ef: e8 74 3e 00 00 call 116668 <_Objects_Allocate> <== NOT EXECUTED 1127f4: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 1127f6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1127f9: 85 c0 test %eax,%eax <== NOT EXECUTED 1127fb: 74 5f je 11285c <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 1127fd: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 112800: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED the_partition->length = length; 112803: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 112806: 89 43 14 mov %eax,0x14(%ebx) <== NOT EXECUTED the_partition->buffer_size = buffer_size; 112809: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 11280c: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED the_partition->attribute_set = attribute_set; 11280f: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 112812: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED the_partition->number_of_used_blocks = 0; 112815: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED _Chain_Initialize( &the_partition->Memory, starting_address, 11281c: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 11281f: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 112822: 31 d2 xor %edx,%edx <== NOT EXECUTED 112824: f7 75 14 divl 0x14(%ebp) <== NOT EXECUTED 112827: 50 push %eax <== NOT EXECUTED 112828: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11282b: 8d 43 24 lea 0x24(%ebx),%eax <== NOT EXECUTED 11282e: 50 push %eax <== NOT EXECUTED 11282f: e8 78 2c 00 00 call 1154ac <_Chain_Initialize> <== NOT EXECUTED 112834: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 112837: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 11283a: a1 1c 59 13 00 mov 0x13591c,%eax <== NOT EXECUTED 11283f: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 112842: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 112845: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 112848: 89 08 mov %ecx,(%eax) <== NOT EXECUTED name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 11284a: e8 91 4b 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 11284f: 31 c0 xor %eax,%eax <== NOT EXECUTED 112851: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112854: e9 70 ff ff ff jmp 1127c9 <== NOT EXECUTED 112859: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { _Thread_Enable_dispatch(); 11285c: e8 7f 4b 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 112861: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 112866: e9 5e ff ff ff jmp 1127c9 <== NOT EXECUTED 0011286c : */ rtems_status_code rtems_partition_delete( Objects_Id id ) { 11286c: 55 push %ebp <== NOT EXECUTED 11286d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11286f: 53 push %ebx <== NOT EXECUTED 112870: 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. 112873: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 112876: 50 push %eax <== NOT EXECUTED 112877: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11287a: 68 00 59 13 00 push $0x135900 <== NOT EXECUTED 11287f: e8 18 43 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED 112884: 89 c3 mov %eax,%ebx <== NOT EXECUTED register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 112886: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112889: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 11288c: 85 c0 test %eax,%eax <== NOT EXECUTED 11288e: 74 0c je 11289c <== NOT EXECUTED 112890: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112895: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112898: c9 leave <== NOT EXECUTED 112899: c3 ret <== NOT EXECUTED 11289a: 66 90 xchg %ax,%ax <== NOT EXECUTED the_partition = _Partition_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( the_partition->number_of_used_blocks == 0 ) { 11289c: 8b 4b 20 mov 0x20(%ebx),%ecx <== NOT EXECUTED 11289f: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1128a1: 74 11 je 1128b4 <== NOT EXECUTED #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 1128a3: e8 38 4b 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 1128a8: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1128ad: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1128b0: c9 leave <== NOT EXECUTED 1128b1: c3 ret <== NOT EXECUTED 1128b2: 66 90 xchg %ax,%ax <== NOT EXECUTED the_partition = _Partition_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( the_partition->number_of_used_blocks == 0 ) { _Objects_Close( &_Partition_Information, &the_partition->Object ); 1128b4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1128b7: 53 push %ebx <== NOT EXECUTED 1128b8: 68 00 59 13 00 push $0x135900 <== NOT EXECUTED 1128bd: e8 26 3e 00 00 call 1166e8 <_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. 1128c2: 58 pop %eax <== NOT EXECUTED 1128c3: 5a pop %edx <== NOT EXECUTED 1128c4: 53 push %ebx <== NOT EXECUTED 1128c5: 68 00 59 13 00 push $0x135900 <== NOT EXECUTED 1128ca: e8 59 41 00 00 call 116a28 <_Objects_Free> <== NOT EXECUTED 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 1128cf: e8 0c 4b 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 1128d4: 31 c0 xor %eax,%eax <== NOT EXECUTED 1128d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1128d9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1128dc: c9 leave <== NOT EXECUTED 1128dd: c3 ret <== NOT EXECUTED 001128e0 : rtems_status_code rtems_partition_get_buffer( Objects_Id id, void **buffer ) { 1128e0: 55 push %ebp <== NOT EXECUTED 1128e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1128e3: 57 push %edi <== NOT EXECUTED 1128e4: 56 push %esi <== NOT EXECUTED 1128e5: 53 push %ebx <== NOT EXECUTED 1128e6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1128e9: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 1128ec: 85 ff test %edi,%edi <== NOT EXECUTED 1128ee: 74 58 je 112948 <== 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. 1128f0: 52 push %edx <== NOT EXECUTED 1128f1: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 1128f4: 50 push %eax <== NOT EXECUTED 1128f5: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1128f8: 68 00 59 13 00 push $0x135900 <== NOT EXECUTED 1128fd: e8 9a 42 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED 112902: 89 c3 mov %eax,%ebx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 112904: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112907: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11290a: 85 c0 test %eax,%eax <== NOT EXECUTED 11290c: 75 2a jne 112938 <== 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 11290e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112911: 8d 43 24 lea 0x24(%ebx),%eax <== NOT EXECUTED 112914: 50 push %eax <== NOT EXECUTED 112915: e8 6a 2b 00 00 call 115484 <_Chain_Get> <== NOT EXECUTED 11291a: 89 c6 mov %eax,%esi <== NOT EXECUTED case OBJECTS_LOCAL: the_buffer = _Partition_Allocate_buffer( the_partition ); if ( the_buffer ) { 11291c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11291f: 85 c0 test %eax,%eax <== NOT EXECUTED 112921: 74 35 je 112958 <== NOT EXECUTED the_partition->number_of_used_blocks += 1; 112923: ff 43 20 incl 0x20(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 112926: e8 b5 4a 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED *buffer = the_buffer; 11292b: 89 37 mov %esi,(%edi) <== NOT EXECUTED 11292d: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11292f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112932: 5b pop %ebx <== NOT EXECUTED 112933: 5e pop %esi <== NOT EXECUTED 112934: 5f pop %edi <== NOT EXECUTED 112935: c9 leave <== NOT EXECUTED 112936: c3 ret <== NOT EXECUTED 112937: 90 nop <== NOT EXECUTED if ( !buffer ) return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 112938: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11293d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112940: 5b pop %ebx <== NOT EXECUTED 112941: 5e pop %esi <== NOT EXECUTED 112942: 5f pop %edi <== NOT EXECUTED 112943: c9 leave <== NOT EXECUTED 112944: c3 ret <== NOT EXECUTED 112945: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 112948: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11294d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112950: 5b pop %ebx <== NOT EXECUTED 112951: 5e pop %esi <== NOT EXECUTED 112952: 5f pop %edi <== NOT EXECUTED 112953: c9 leave <== NOT EXECUTED 112954: c3 ret <== NOT EXECUTED 112955: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_partition->number_of_used_blocks += 1; _Thread_Enable_dispatch(); *buffer = the_buffer; return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 112958: e8 83 4a 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 11295d: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 112962: eb d9 jmp 11293d <== NOT EXECUTED 00112964 : rtems_status_code rtems_partition_ident( rtems_name name, uint32_t node, Objects_Id *id ) { 112964: 55 push %ebp <== NOT EXECUTED 112965: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112967: 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 ); 11296a: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 11296d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 112970: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112973: 68 00 59 13 00 push $0x135900 <== NOT EXECUTED 112978: e8 77 43 00 00 call 116cf4 <_Objects_Name_to_id_u32> <== NOT EXECUTED 11297d: 8b 04 85 8c a7 12 00 mov 0x12a78c(,%eax,4),%eax <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; } 112984: c9 leave <== NOT EXECUTED 112985: c3 ret <== NOT EXECUTED 00112988 : rtems_status_code rtems_partition_return_buffer( Objects_Id id, void *buffer ) { 112988: 55 push %ebp <== NOT EXECUTED 112989: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11298b: 53 push %ebx <== NOT EXECUTED 11298c: 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. 11298f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 112992: 50 push %eax <== NOT EXECUTED 112993: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112996: 68 00 59 13 00 push $0x135900 <== NOT EXECUTED 11299b: e8 fc 41 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED 1129a0: 89 c3 mov %eax,%ebx <== NOT EXECUTED register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 1129a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1129a5: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 1129a8: 85 c0 test %eax,%eax <== NOT EXECUTED 1129aa: 74 0c je 1129b8 <== NOT EXECUTED 1129ac: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1129b1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1129b4: c9 leave <== NOT EXECUTED 1129b5: c3 ret <== NOT EXECUTED 1129b6: 66 90 xchg %ax,%ax <== 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 ); 1129b8: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED 1129bb: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 1129be: 39 55 0c cmp %edx,0xc(%ebp) <== NOT EXECUTED 1129c1: 73 11 jae 1129d4 <== NOT EXECUTED _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 1129c3: e8 18 4a 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 1129c8: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1129cd: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1129d0: c9 leave <== NOT EXECUTED 1129d1: c3 ret <== NOT EXECUTED 1129d2: 66 90 xchg %ax,%ax <== NOT EXECUTED 1129d4: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED 1129d7: 39 45 0c cmp %eax,0xc(%ebp) <== NOT EXECUTED 1129da: 77 e7 ja 1129c3 <== NOT EXECUTED Heap_Control *the_heap, size_t size ); /** * This function attempts to allocate a memory block of @a size bytes from 1129dc: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1129df: 29 d0 sub %edx,%eax <== NOT EXECUTED 1129e1: 31 d2 xor %edx,%edx <== NOT EXECUTED 1129e3: f7 73 18 divl 0x18(%ebx) <== NOT EXECUTED 1129e6: 85 d2 test %edx,%edx <== NOT EXECUTED 1129e8: 75 d9 jne 1129c3 <== 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( 1129ea: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1129ed: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1129f0: 8d 43 24 lea 0x24(%ebx),%eax <== NOT EXECUTED 1129f3: 50 push %eax <== NOT EXECUTED 1129f4: e8 67 2a 00 00 call 115460 <_Chain_Append> <== NOT EXECUTED switch ( location ) { case OBJECTS_LOCAL: if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) { _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; 1129f9: ff 4b 20 decl 0x20(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 1129fc: e8 df 49 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 112a01: 31 c0 xor %eax,%eax <== NOT EXECUTED 112a03: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112a06: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112a09: c9 leave <== NOT EXECUTED 112a0a: c3 ret <== NOT EXECUTED 00111db4 : void *internal_start, void *external_start, uint32_t length, Objects_Id *id ) { 111db4: 55 push %ebp <== NOT EXECUTED 111db5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111db7: 56 push %esi <== NOT EXECUTED 111db8: 53 push %ebx <== NOT EXECUTED 111db9: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name) ) 111dbc: 85 f6 test %esi,%esi <== NOT EXECUTED 111dbe: 74 20 je 111de0 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 111dc0: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 111dc3: 85 c0 test %eax,%eax <== NOT EXECUTED 111dc5: 74 0a je 111dd1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( internal_start ) || 111dc7: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 111dca: 0b 45 0c or 0xc(%ebp),%eax <== NOT EXECUTED 111dcd: a8 03 test $0x3,%al <== NOT EXECUTED 111dcf: 74 1b je 111dec <== NOT EXECUTED (Objects_Name) name ); *id = the_port->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 111dd1: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED } 111dd6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111dd9: 5b pop %ebx <== NOT EXECUTED 111dda: 5e pop %esi <== NOT EXECUTED 111ddb: c9 leave <== NOT EXECUTED 111ddc: c3 ret <== NOT EXECUTED 111ddd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED Objects_Id *id ) { register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name) ) 111de0: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED ); *id = the_port->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 111de5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111de8: 5b pop %ebx <== NOT EXECUTED 111de9: 5e pop %esi <== NOT EXECUTED 111dea: c9 leave <== NOT EXECUTED 111deb: c3 ret <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 111dec: a1 f8 5a 13 00 mov 0x135af8,%eax <== NOT EXECUTED 111df1: 40 inc %eax <== NOT EXECUTED 111df2: a3 f8 5a 13 00 mov %eax,0x135af8 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** * This routine initializes @a the_heap record to manage the 111df7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111dfa: 68 c0 58 13 00 push $0x1358c0 <== NOT EXECUTED 111dff: e8 64 48 00 00 call 116668 <_Objects_Allocate> <== NOT EXECUTED 111e04: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { 111e06: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111e09: 85 c0 test %eax,%eax <== NOT EXECUTED 111e0b: 74 37 je 111e44 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; 111e0d: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 111e10: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED the_port->external_base = external_start; 111e13: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 111e16: 89 43 14 mov %eax,0x14(%ebx) <== NOT EXECUTED the_port->length = length - 1; 111e19: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 111e1c: 48 dec %eax <== NOT EXECUTED 111e1d: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED 111e20: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 111e23: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 111e26: a1 dc 58 13 00 mov 0x1358dc,%eax <== NOT EXECUTED 111e2b: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 111e2e: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Dual_ported_memory_Information, &the_port->Object, (Objects_Name) name ); *id = the_port->Object.id; 111e31: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 111e34: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 111e36: e8 a5 55 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 111e3b: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 111e3d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111e40: 5b pop %ebx <== NOT EXECUTED 111e41: 5e pop %esi <== NOT EXECUTED 111e42: c9 leave <== NOT EXECUTED 111e43: c3 ret <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { _Thread_Enable_dispatch(); 111e44: e8 97 55 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 111e49: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 111e4e: eb 86 jmp 111dd6 <== NOT EXECUTED 00111e50 : */ rtems_status_code rtems_port_delete( Objects_Id id ) { 111e50: 55 push %ebp <== NOT EXECUTED 111e51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111e53: 53 push %ebx <== NOT EXECUTED 111e54: 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 111e57: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 111e5a: 50 push %eax <== NOT EXECUTED 111e5b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111e5e: 68 c0 58 13 00 push $0x1358c0 <== NOT EXECUTED 111e63: e8 34 4d 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED 111e68: 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 ) { 111e6a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111e6d: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 111e70: 85 c9 test %ecx,%ecx <== NOT EXECUTED 111e72: 75 2c jne 111ea0 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Dual_ported_memory_Information, &the_port->Object ); 111e74: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111e77: 50 push %eax <== NOT EXECUTED 111e78: 68 c0 58 13 00 push $0x1358c0 <== NOT EXECUTED 111e7d: e8 66 48 00 00 call 1166e8 <_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. */ 111e82: 58 pop %eax <== NOT EXECUTED 111e83: 5a pop %edx <== NOT EXECUTED 111e84: 53 push %ebx <== NOT EXECUTED 111e85: 68 c0 58 13 00 push $0x1358c0 <== NOT EXECUTED 111e8a: e8 99 4b 00 00 call 116a28 <_Objects_Free> <== NOT EXECUTED _Dual_ported_memory_Free( the_port ); _Thread_Enable_dispatch(); 111e8f: e8 4c 55 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 111e94: 31 c0 xor %eax,%eax <== NOT EXECUTED 111e96: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111e99: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111e9c: c9 leave <== NOT EXECUTED 111e9d: c3 ret <== NOT EXECUTED 111e9e: 66 90 xchg %ax,%ax <== NOT EXECUTED { register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 111ea0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111ea5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111ea8: c9 leave <== NOT EXECUTED 111ea9: c3 ret <== NOT EXECUTED 00111eac : rtems_status_code rtems_port_external_to_internal( Objects_Id id, void *external, void **internal ) { 111eac: 55 push %ebp <== NOT EXECUTED 111ead: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111eaf: 53 push %ebx <== NOT EXECUTED 111eb0: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 111eb3: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !internal ) 111eb6: 85 db test %ebx,%ebx <== NOT EXECUTED 111eb8: 74 4e je 111f08 <== 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 111eba: 51 push %ecx <== NOT EXECUTED 111ebb: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 111ebe: 50 push %eax <== NOT EXECUTED 111ebf: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111ec2: 68 c0 58 13 00 push $0x1358c0 <== NOT EXECUTED 111ec7: e8 d0 4c 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 111ecc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111ecf: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 111ed2: 85 d2 test %edx,%edx <== NOT EXECUTED 111ed4: 75 1e jne 111ef4 <== 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 */ 111ed6: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 111ed9: 2b 50 14 sub 0x14(%eax),%edx <== NOT EXECUTED case OBJECTS_LOCAL: ending = _Addresses_Subtract( external, the_port->external_base ); if ( ending > the_port->length ) 111edc: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED 111edf: 73 1f jae 111f00 <== NOT EXECUTED *internal = external; 111ee1: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 111ee4: 89 03 mov %eax,(%ebx) <== NOT EXECUTED else *internal = _Addresses_Add_offset( the_port->internal_base, ending ); _Thread_Enable_dispatch(); 111ee6: e8 f5 54 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 111eeb: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111eed: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111ef0: c9 leave <== NOT EXECUTED 111ef1: c3 ret <== NOT EXECUTED 111ef2: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !internal ) return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 111ef4: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111ef9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111efc: c9 leave <== NOT EXECUTED 111efd: c3 ret <== NOT EXECUTED 111efe: 66 90 xchg %ax,%ax <== NOT EXECUTED case OBJECTS_LOCAL: ending = _Addresses_Subtract( external, the_port->external_base ); if ( ending > the_port->length ) *internal = external; else *internal = _Addresses_Add_offset( the_port->internal_base, 111f00: 03 50 10 add 0x10(%eax),%edx <== NOT EXECUTED 111f03: 89 13 mov %edx,(%ebx) <== NOT EXECUTED 111f05: eb df jmp 111ee6 <== NOT EXECUTED 111f07: 90 nop <== NOT EXECUTED { register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !internal ) 111f08: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111f0d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111f10: c9 leave <== NOT EXECUTED 111f11: c3 ret <== NOT EXECUTED 00111f14 : rtems_status_code rtems_port_ident( rtems_name name, Objects_Id *id ) { 111f14: 55 push %ebp <== NOT EXECUTED 111f15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111f17: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 111f1a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111f1d: 6a 00 push $0x0 <== NOT EXECUTED 111f1f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111f22: 68 c0 58 13 00 push $0x1358c0 <== NOT EXECUTED 111f27: e8 c8 4d 00 00 call 116cf4 <_Objects_Name_to_id_u32> <== NOT EXECUTED 111f2c: 8b 04 85 8c a7 12 00 mov 0x12a78c(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_ALL_NODES, id ); return _Status_Object_name_errors_to_status[ status ]; } 111f33: c9 leave <== NOT EXECUTED 111f34: c3 ret <== NOT EXECUTED 00111f38 : rtems_status_code rtems_port_internal_to_external( Objects_Id id, void *internal, void **external ) { 111f38: 55 push %ebp <== NOT EXECUTED 111f39: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111f3b: 53 push %ebx <== NOT EXECUTED 111f3c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 111f3f: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !external ) 111f42: 85 db test %ebx,%ebx <== NOT EXECUTED 111f44: 74 4e je 111f94 <== 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 111f46: 51 push %ecx <== NOT EXECUTED 111f47: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 111f4a: 50 push %eax <== NOT EXECUTED 111f4b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111f4e: 68 c0 58 13 00 push $0x1358c0 <== NOT EXECUTED 111f53: e8 44 4c 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 111f58: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111f5b: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 111f5e: 85 d2 test %edx,%edx <== NOT EXECUTED 111f60: 75 1e jne 111f80 <== 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 */ 111f62: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 111f65: 2b 50 10 sub 0x10(%eax),%edx <== NOT EXECUTED case OBJECTS_LOCAL: ending = _Addresses_Subtract( internal, the_port->internal_base ); if ( ending > the_port->length ) 111f68: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED 111f6b: 73 1f jae 111f8c <== NOT EXECUTED *external = internal; 111f6d: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 111f70: 89 03 mov %eax,(%ebx) <== NOT EXECUTED else *external = _Addresses_Add_offset( the_port->external_base, ending ); _Thread_Enable_dispatch(); 111f72: e8 69 54 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 111f77: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111f79: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111f7c: c9 leave <== NOT EXECUTED 111f7d: c3 ret <== NOT EXECUTED 111f7e: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !external ) return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 111f80: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111f85: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111f88: c9 leave <== NOT EXECUTED 111f89: c3 ret <== NOT EXECUTED 111f8a: 66 90 xchg %ax,%ax <== NOT EXECUTED case OBJECTS_LOCAL: ending = _Addresses_Subtract( internal, the_port->internal_base ); if ( ending > the_port->length ) *external = internal; else *external = _Addresses_Add_offset( the_port->external_base, 111f8c: 03 50 14 add 0x14(%eax),%edx <== NOT EXECUTED 111f8f: 89 13 mov %edx,(%ebx) <== NOT EXECUTED 111f91: eb df jmp 111f72 <== NOT EXECUTED 111f93: 90 nop <== NOT EXECUTED { register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !external ) 111f94: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111f99: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111f9c: c9 leave <== NOT EXECUTED 111f9d: c3 ret <== NOT EXECUTED 00112a0c : */ rtems_status_code rtems_rate_monotonic_cancel( Objects_Id id ) { 112a0c: 55 push %ebp <== NOT EXECUTED 112a0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112a0f: 53 push %ebx <== NOT EXECUTED 112a10: 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 112a13: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 112a16: 50 push %eax <== NOT EXECUTED 112a17: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112a1a: 68 40 59 13 00 push $0x135940 <== NOT EXECUTED 112a1f: e8 78 41 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED 112a24: 89 c3 mov %eax,%ebx <== NOT EXECUTED Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 112a26: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112a29: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 112a2c: 85 c0 test %eax,%eax <== NOT EXECUTED 112a2e: 74 0c je 112a3c <== NOT EXECUTED 112a30: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112a35: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112a38: c9 leave <== NOT EXECUTED 112a39: c3 ret <== NOT EXECUTED 112a3a: 66 90 xchg %ax,%ax <== NOT EXECUTED the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 112a3c: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 112a3f: 3b 05 bc 5b 13 00 cmp 0x135bbc,%eax <== NOT EXECUTED 112a45: 74 11 je 112a58 <== NOT EXECUTED _Thread_Enable_dispatch(); 112a47: e8 94 49 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 112a4c: b8 17 00 00 00 mov $0x17,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112a51: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112a54: c9 leave <== NOT EXECUTED 112a55: c3 ret <== NOT EXECUTED 112a56: 66 90 xchg %ax,%ax <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } (void) _Watchdog_Remove( &the_period->Timer ); 112a58: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112a5b: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 112a5e: 50 push %eax <== NOT EXECUTED 112a5f: e8 74 5d 00 00 call 1187d8 <_Watchdog_Remove> <== NOT EXECUTED the_period->state = RATE_MONOTONIC_INACTIVE; 112a64: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 112a6b: e8 70 49 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 112a70: 31 c0 xor %eax,%eax <== NOT EXECUTED 112a72: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112a75: eb be jmp 112a35 <== NOT EXECUTED 0010af98 : rtems_status_code rtems_rate_monotonic_create( rtems_name name, Objects_Id *id ) { 10af98: 55 push %ebp <== NOT EXECUTED 10af99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10af9b: 57 push %edi <== NOT EXECUTED 10af9c: 56 push %esi <== NOT EXECUTED 10af9d: 53 push %ebx <== NOT EXECUTED 10af9e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10afa1: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 10afa4: 85 f6 test %esi,%esi <== NOT EXECUTED 10afa6: 0f 84 a8 00 00 00 je 10b054 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 10afac: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10afaf: 85 c0 test %eax,%eax <== NOT EXECUTED 10afb1: 0f 84 c1 00 00 00 je 10b078 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10afb7: a1 78 27 12 00 mov 0x122778,%eax <== NOT EXECUTED 10afbc: 40 inc %eax <== NOT EXECUTED 10afbd: a3 78 27 12 00 mov %eax,0x122778 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 10afc2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10afc5: 68 80 26 12 00 push $0x122680 <== NOT EXECUTED 10afca: e8 d9 1d 00 00 call 10cda8 <_Objects_Allocate> <== NOT EXECUTED 10afcf: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { 10afd1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10afd4: 85 c0 test %eax,%eax <== NOT EXECUTED 10afd6: 0f 84 88 00 00 00 je 10b064 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 10afdc: a1 3c 28 12 00 mov 0x12283c,%eax <== NOT EXECUTED 10afe1: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED the_period->state = RATE_MONOTONIC_INACTIVE; 10afe4: 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. * 10afeb: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10aff2: 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 10aff9: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx) <== NOT EXECUTED * the heap 10b000: 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 ); 10b007: 8d 7b 54 lea 0x54(%ebx),%edi <== NOT EXECUTED 10b00a: b9 38 00 00 00 mov $0x38,%ecx <== NOT EXECUTED 10b00f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b011: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 10b013: c7 43 5c ff ff ff 7f movl $0x7fffffff,0x5c(%ebx) <== NOT EXECUTED 10b01a: c7 43 60 ff ff ff 7f movl $0x7fffffff,0x60(%ebx) <== NOT EXECUTED 10b021: c7 43 74 ff ff ff 7f movl $0x7fffffff,0x74(%ebx) <== NOT EXECUTED 10b028: c7 43 78 ff ff ff 7f movl $0x7fffffff,0x78(%ebx) <== NOT EXECUTED 10b02f: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10b032: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10b035: a1 9c 26 12 00 mov 0x12269c,%eax <== NOT EXECUTED 10b03a: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10b03d: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Rate_monotonic_Information, &the_period->Object, (Objects_Name) name ); *id = the_period->Object.id; 10b040: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b043: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10b045: e8 96 2b 00 00 call 10dbe0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b04a: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10b04c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b04f: 5b pop %ebx <== NOT EXECUTED 10b050: 5e pop %esi <== NOT EXECUTED 10b051: 5f pop %edi <== NOT EXECUTED 10b052: c9 leave <== NOT EXECUTED 10b053: c3 ret <== NOT EXECUTED Objects_Id *id ) { Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 10b054: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b059: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b05c: 5b pop %ebx <== NOT EXECUTED 10b05d: 5e pop %esi <== NOT EXECUTED 10b05e: 5f pop %edi <== NOT EXECUTED 10b05f: c9 leave <== NOT EXECUTED 10b060: c3 ret <== NOT EXECUTED 10b061: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { _Thread_Enable_dispatch(); 10b064: e8 77 2b 00 00 call 10dbe0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b069: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b06e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b071: 5b pop %ebx <== NOT EXECUTED 10b072: 5e pop %esi <== NOT EXECUTED 10b073: 5f pop %edi <== NOT EXECUTED 10b074: c9 leave <== NOT EXECUTED 10b075: c3 ret <== NOT EXECUTED 10b076: 66 90 xchg %ax,%ax <== NOT EXECUTED Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 10b078: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b07d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b080: 5b pop %ebx <== NOT EXECUTED 10b081: 5e pop %esi <== NOT EXECUTED 10b082: 5f pop %edi <== NOT EXECUTED 10b083: c9 leave <== NOT EXECUTED 10b084: c3 ret <== NOT EXECUTED 00112b68 : */ rtems_status_code rtems_rate_monotonic_delete( Objects_Id id ) { 112b68: 55 push %ebp <== NOT EXECUTED 112b69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112b6b: 53 push %ebx <== NOT EXECUTED 112b6c: 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 112b6f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 112b72: 50 push %eax <== NOT EXECUTED 112b73: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112b76: 68 40 59 13 00 push $0x135940 <== NOT EXECUTED 112b7b: e8 1c 40 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED 112b80: 89 c3 mov %eax,%ebx <== NOT EXECUTED Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 112b82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112b85: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 112b88: 85 c9 test %ecx,%ecx <== NOT EXECUTED 112b8a: 75 3c jne 112bc8 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Rate_monotonic_Information, &the_period->Object ); 112b8c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 112b8f: 50 push %eax <== NOT EXECUTED 112b90: 68 40 59 13 00 push $0x135940 <== NOT EXECUTED 112b95: e8 4e 3b 00 00 call 1166e8 <_Objects_Close> <== NOT EXECUTED (void) _Watchdog_Remove( &the_period->Timer ); 112b9a: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 112b9d: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 112ba0: e8 33 5c 00 00 call 1187d8 <_Watchdog_Remove> <== NOT EXECUTED the_period->state = RATE_MONOTONIC_INACTIVE; 112ba5: 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. 112bac: 58 pop %eax <== NOT EXECUTED 112bad: 5a pop %edx <== NOT EXECUTED 112bae: 53 push %ebx <== NOT EXECUTED 112baf: 68 40 59 13 00 push $0x135940 <== NOT EXECUTED 112bb4: e8 6f 3e 00 00 call 116a28 <_Objects_Free> <== NOT EXECUTED _Rate_monotonic_Free( the_period ); _Thread_Enable_dispatch(); 112bb9: e8 22 48 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 112bbe: 31 c0 xor %eax,%eax <== NOT EXECUTED 112bc0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112bc3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112bc6: c9 leave <== NOT EXECUTED 112bc7: c3 ret <== NOT EXECUTED { Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 112bc8: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112bcd: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112bd0: c9 leave <== NOT EXECUTED 112bd1: c3 ret <== NOT EXECUTED 0012f4d4 : rtems_status_code rtems_rate_monotonic_get_statistics( Objects_Id id, rtems_rate_monotonic_period_statistics *statistics ) { 12f4d4: 55 push %ebp <== NOT EXECUTED 12f4d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f4d7: 57 push %edi <== NOT EXECUTED 12f4d8: 56 push %esi <== NOT EXECUTED 12f4d9: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 12f4dc: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 12f4df: 85 ff test %edi,%edi <== NOT EXECUTED 12f4e1: 74 41 je 12f524 <== 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 12f4e3: 51 push %ecx <== NOT EXECUTED 12f4e4: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 12f4e7: 50 push %eax <== NOT EXECUTED 12f4e8: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12f4eb: 68 40 18 16 00 push $0x161840 <== NOT EXECUTED 12f4f0: e8 eb 18 fe ff call 110de0 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 12f4f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12f4f8: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 12f4fb: 85 d2 test %edx,%edx <== NOT EXECUTED 12f4fd: 74 0d je 12f50c <== NOT EXECUTED 12f4ff: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12f504: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12f507: 5e pop %esi <== NOT EXECUTED 12f508: 5f pop %edi <== NOT EXECUTED 12f509: c9 leave <== NOT EXECUTED 12f50a: c3 ret <== NOT EXECUTED 12f50b: 90 nop <== NOT EXECUTED the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: *statistics = the_period->Statistics; 12f50c: 8d 70 54 lea 0x54(%eax),%esi <== NOT EXECUTED 12f50f: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 12f514: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 12f516: e8 b9 21 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 12f51b: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12f51d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12f520: 5e pop %esi <== NOT EXECUTED 12f521: 5f pop %edi <== NOT EXECUTED 12f522: c9 leave <== NOT EXECUTED 12f523: c3 ret <== NOT EXECUTED ) { Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 12f524: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12f529: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12f52c: 5e pop %esi <== NOT EXECUTED 12f52d: 5f pop %edi <== NOT EXECUTED 12f52e: c9 leave <== NOT EXECUTED 12f52f: c3 ret <== NOT EXECUTED 0012f530 : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 12f530: 55 push %ebp <== NOT EXECUTED 12f531: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f533: 57 push %edi <== NOT EXECUTED 12f534: 56 push %esi <== NOT EXECUTED 12f535: 53 push %ebx <== NOT EXECUTED 12f536: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 12f539: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 12f53c: 85 f6 test %esi,%esi <== NOT EXECUTED 12f53e: 74 70 je 12f5b0 <== NOT EXECUTED 12f540: 52 push %edx <== NOT EXECUTED 12f541: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 12f544: 50 push %eax <== NOT EXECUTED 12f545: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12f548: 68 40 18 16 00 push $0x161840 <== NOT EXECUTED 12f54d: e8 8e 18 fe ff call 110de0 <_Objects_Get> <== NOT EXECUTED 12f552: 89 c7 mov %eax,%edi <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 12f554: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12f557: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 12f55a: 85 c0 test %eax,%eax <== NOT EXECUTED 12f55c: 75 42 jne 12f5a0 <== NOT EXECUTED case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 12f55e: 8b 47 50 mov 0x50(%edi),%eax <== NOT EXECUTED 12f561: 85 c0 test %eax,%eax <== NOT EXECUTED 12f563: 74 03 je 12f568 <== NOT EXECUTED 12f565: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 12f568: 89 06 mov %eax,(%esi) <== NOT EXECUTED status->state = the_period->state; 12f56a: 8b 47 38 mov 0x38(%edi),%eax <== NOT EXECUTED 12f56d: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED if ( status->state == RATE_MONOTONIC_INACTIVE ) { 12f570: 85 c0 test %eax,%eax <== NOT EXECUTED 12f572: 75 4c jne 12f5c0 <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS status->since_last_period.tv_sec = 0; 12f574: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) <== NOT EXECUTED status->since_last_period.tv_nsec = 0; 12f57b: 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; 12f582: c7 46 10 00 00 00 00 movl $0x0,0x10(%esi) <== NOT EXECUTED status->executed_since_last_period.tv_nsec = 0; 12f589: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED the_period->owner->cpu_time_used - the_period->owner_executed_at_period; #endif } _Thread_Enable_dispatch(); 12f590: e8 3f 21 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 12f595: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12f597: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12f59a: 5b pop %ebx <== NOT EXECUTED 12f59b: 5e pop %esi <== NOT EXECUTED 12f59c: 5f pop %edi <== NOT EXECUTED 12f59d: c9 leave <== NOT EXECUTED 12f59e: c3 ret <== NOT EXECUTED 12f59f: 90 nop <== NOT EXECUTED if ( !status ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 12f5a0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12f5a5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12f5a8: 5b pop %ebx <== NOT EXECUTED 12f5a9: 5e pop %esi <== NOT EXECUTED 12f5aa: 5f pop %edi <== NOT EXECUTED 12f5ab: c9 leave <== NOT EXECUTED 12f5ac: c3 ret <== NOT EXECUTED 12f5ad: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 12f5b0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12f5b5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12f5b8: 5b pop %ebx <== NOT EXECUTED 12f5b9: 5e pop %esi <== NOT EXECUTED 12f5ba: 5f pop %edi <== NOT EXECUTED 12f5bb: c9 leave <== NOT EXECUTED 12f5bc: c3 ret <== NOT EXECUTED 12f5bd: 8d 76 00 lea 0x0(%esi),%esi <== 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 ); 12f5c0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12f5c3: 8d 5d e8 lea -0x18(%ebp),%ebx <== NOT EXECUTED 12f5c6: 53 push %ebx <== NOT EXECUTED 12f5c7: e8 c0 70 ff ff call 12668c <_TOD_Get_uptime> <== NOT EXECUTED #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 12f5cc: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 12f5cf: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED 12f5d2: 50 push %eax <== NOT EXECUTED 12f5d3: 53 push %ebx <== NOT EXECUTED 12f5d4: 8d 47 44 lea 0x44(%edi),%eax <== NOT EXECUTED 12f5d7: 50 push %eax <== NOT EXECUTED 12f5d8: e8 5f 2d fe ff call 11233c <_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( 12f5dd: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 12f5e0: 8d 46 10 lea 0x10(%esi),%eax <== NOT EXECUTED 12f5e3: 50 push %eax <== NOT EXECUTED 12f5e4: 53 push %ebx <== NOT EXECUTED 12f5e5: 68 e4 12 16 00 push $0x1612e4 <== NOT EXECUTED 12f5ea: e8 4d 2d fe ff call 11233c <_Timespec_Subtract> <== NOT EXECUTED 12f5ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12f5f2: eb 9c jmp 12f590 <== NOT EXECUTED 0010b088 : rtems_status_code rtems_rate_monotonic_ident( rtems_name name, Objects_Id *id ) { 10b088: 55 push %ebp <== NOT EXECUTED 10b089: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b08b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 10b08e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b091: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 10b096: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b099: 68 80 26 12 00 push $0x122680 <== NOT EXECUTED 10b09e: e8 51 24 00 00 call 10d4f4 <_Objects_Name_to_id_u32> <== NOT EXECUTED 10b0a3: 8b 04 85 ac bc 11 00 mov 0x11bcac(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 10b0aa: c9 leave <== NOT EXECUTED 10b0ab: c3 ret <== NOT EXECUTED 0010b270 : rtems_status_code rtems_rate_monotonic_period( Objects_Id id, rtems_interval length ) { 10b270: 55 push %ebp <== NOT EXECUTED 10b271: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b273: 57 push %edi <== NOT EXECUTED 10b274: 56 push %esi <== NOT EXECUTED 10b275: 53 push %ebx <== NOT EXECUTED 10b276: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 10b279: 8b 75 08 mov 0x8(%ebp),%esi <== 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 10b27c: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b27f: 50 push %eax <== NOT EXECUTED 10b280: 56 push %esi <== NOT EXECUTED 10b281: 68 80 26 12 00 push $0x122680 <== NOT EXECUTED 10b286: e8 11 21 00 00 call 10d39c <_Objects_Get> <== NOT EXECUTED 10b28b: 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 ) { 10b28d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b290: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10b293: 85 c0 test %eax,%eax <== NOT EXECUTED 10b295: 74 11 je 10b2a8 <== NOT EXECUTED the_period->state = RATE_MONOTONIC_ACTIVE; the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); return RTEMS_TIMEOUT; 10b297: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b29c: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b29e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b2a1: 5b pop %ebx <== NOT EXECUTED 10b2a2: 5e pop %esi <== NOT EXECUTED 10b2a3: 5f pop %edi <== NOT EXECUTED 10b2a4: c9 leave <== NOT EXECUTED 10b2a5: c3 ret <== NOT EXECUTED 10b2a6: 66 90 xchg %ax,%ax <== NOT EXECUTED the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 10b2a8: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 10b2ab: 3b 05 3c 28 12 00 cmp 0x12283c,%eax <== NOT EXECUTED 10b2b1: 74 15 je 10b2c8 <== NOT EXECUTED _Thread_Enable_dispatch(); 10b2b3: e8 28 29 00 00 call 10dbe0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b2b8: bb 17 00 00 00 mov $0x17,%ebx <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b2bd: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b2bf: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b2c2: 5b pop %ebx <== NOT EXECUTED 10b2c3: 5e pop %esi <== NOT EXECUTED 10b2c4: 5f pop %edi <== NOT EXECUTED 10b2c5: c9 leave <== NOT EXECUTED 10b2c6: c3 ret <== NOT EXECUTED 10b2c7: 90 nop <== NOT EXECUTED if ( !_Thread_Is_executing( the_period->owner ) ) { _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 10b2c8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b2cb: 85 c0 test %eax,%eax <== NOT EXECUTED 10b2cd: 0f 84 c1 00 00 00 je 10b394 <== NOT EXECUTED } _Thread_Enable_dispatch(); return( return_value ); } _ISR_Disable( level ); 10b2d3: 9c pushf <== NOT EXECUTED 10b2d4: fa cli <== NOT EXECUTED 10b2d5: 5f pop %edi <== NOT EXECUTED switch ( the_period->state ) { 10b2d6: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10b2d9: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b2dc: 74 62 je 10b340 <== NOT EXECUTED 10b2de: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10b2e1: 0f 84 c5 00 00 00 je 10b3ac <== NOT EXECUTED 10b2e7: 85 c0 test %eax,%eax <== NOT EXECUTED 10b2e9: 75 ac jne 10b297 <== NOT EXECUTED case RATE_MONOTONIC_INACTIVE: { _ISR_Enable( level ); 10b2eb: 57 push %edi <== NOT EXECUTED 10b2ec: 9d popf <== NOT EXECUTED /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 10b2ed: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b2f0: 53 push %ebx <== NOT EXECUTED 10b2f1: e8 b6 fd ff ff call 10b0ac <_Rate_monotonic_Initiate_statistics> <== NOT EXECUTED the_period->state = RATE_MONOTONIC_ACTIVE; 10b2f6: 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. * 10b2fd: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10b304: c7 43 2c e0 b6 10 00 movl $0x10b6e0,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10b30b: 89 73 30 mov %esi,0x30(%ebx) <== NOT EXECUTED * the heap 10b30e: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 10b315: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b318: 89 43 4c mov %eax,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, 10b31b: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10b31e: 5f pop %edi <== NOT EXECUTED 10b31f: 58 pop %eax <== NOT EXECUTED 10b320: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10b323: 50 push %eax <== NOT EXECUTED 10b324: 68 5c 28 12 00 push $0x12285c <== NOT EXECUTED 10b329: e8 86 39 00 00 call 10ecb4 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 10b32e: e8 ad 28 00 00 call 10dbe0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b333: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b335: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b338: e9 5f ff ff ff jmp 10b29c <== NOT EXECUTED 10b33d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED case RATE_MONOTONIC_ACTIVE: /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 10b340: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b343: 53 push %ebx <== NOT EXECUTED 10b344: e8 d3 fd ff ff call 10b11c <_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; 10b349: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) <== NOT EXECUTED the_period->next_length = length; 10b350: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b353: 89 43 4c mov %eax,0x4c(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10b356: 57 push %edi <== NOT EXECUTED 10b357: 9d popf <== NOT EXECUTED _Thread_Executing->Wait.id = the_period->Object.id; 10b358: 8b 15 3c 28 12 00 mov 0x12283c,%edx <== NOT EXECUTED 10b35e: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10b361: 89 42 20 mov %eax,0x20(%edx) <== NOT EXECUTED _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b364: 59 pop %ecx <== NOT EXECUTED 10b365: 5e pop %esi <== NOT EXECUTED 10b366: 68 00 40 00 00 push $0x4000 <== NOT EXECUTED 10b36b: 52 push %edx <== NOT EXECUTED 10b36c: e8 4f 31 00 00 call 10e4c0 <_Thread_Set_state> <== NOT EXECUTED /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 10b371: 9c pushf <== NOT EXECUTED 10b372: fa cli <== NOT EXECUTED 10b373: 58 pop %eax <== NOT EXECUTED local_state = the_period->state; 10b374: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED the_period->state = RATE_MONOTONIC_ACTIVE; 10b377: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10b37e: 50 push %eax <== NOT EXECUTED 10b37f: 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 ) 10b380: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b383: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 10b386: 74 71 je 10b3f9 <== NOT EXECUTED _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); _Thread_Enable_dispatch(); 10b388: e8 53 28 00 00 call 10dbe0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b38d: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b38f: e9 08 ff ff ff jmp 10b29c <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { switch ( the_period->state ) { 10b394: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10b397: 85 c0 test %eax,%eax <== NOT EXECUTED 10b399: 75 51 jne 10b3ec <== NOT EXECUTED 10b39b: bb 0b 00 00 00 mov $0xb,%ebx <== NOT EXECUTED case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 10b3a0: e8 3b 28 00 00 call 10dbe0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b3a5: e9 f2 fe ff ff jmp 10b29c <== NOT EXECUTED 10b3aa: 66 90 xchg %ax,%ax <== NOT EXECUTED case RATE_MONOTONIC_EXPIRED: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 10b3ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b3af: 53 push %ebx <== NOT EXECUTED 10b3b0: e8 67 fd ff ff call 10b11c <_Rate_monotonic_Update_statistics> <== NOT EXECUTED _ISR_Enable( level ); 10b3b5: 57 push %edi <== NOT EXECUTED 10b3b6: 9d popf <== NOT EXECUTED the_period->state = RATE_MONOTONIC_ACTIVE; 10b3b7: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx) <== NOT EXECUTED the_period->next_length = length; 10b3be: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b3c1: 89 43 4c mov %eax,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, 10b3c4: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10b3c7: 58 pop %eax <== NOT EXECUTED 10b3c8: 5a pop %edx <== NOT EXECUTED 10b3c9: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10b3cc: 50 push %eax <== NOT EXECUTED 10b3cd: 68 5c 28 12 00 push $0x12285c <== NOT EXECUTED 10b3d2: e8 dd 38 00 00 call 10ecb4 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 10b3d7: e8 04 28 00 00 call 10dbe0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b3dc: bb 06 00 00 00 mov $0x6,%ebx <== NOT EXECUTED 10b3e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b3e4: e9 b3 fe ff ff jmp 10b29c <== NOT EXECUTED 10b3e9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { switch ( the_period->state ) { 10b3ec: 83 e8 03 sub $0x3,%eax <== NOT EXECUTED 10b3ef: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b3f2: 19 db sbb %ebx,%ebx <== NOT EXECUTED 10b3f4: 83 e3 06 and $0x6,%ebx <== NOT EXECUTED 10b3f7: eb a7 jmp 10b3a0 <== 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 ) _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b3f9: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b3fc: 68 00 40 00 00 push $0x4000 <== NOT EXECUTED 10b401: ff 35 3c 28 12 00 pushl 0x12283c <== NOT EXECUTED 10b407: e8 2c 24 00 00 call 10d838 <_Thread_Clear_state> <== NOT EXECUTED 10b40c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b40f: e9 74 ff ff ff jmp 10b388 <== NOT EXECUTED 00125c2c : } } } void rtems_rate_monotonic_report_statistics( void ) { 125c2c: 55 push %ebp <== NOT EXECUTED 125c2d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125c2f: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin ); 125c32: 68 8c c7 10 00 push $0x10c78c <== NOT EXECUTED 125c37: 6a 00 push $0x0 <== NOT EXECUTED 125c39: e8 de fd ff ff call 125a1c <== NOT EXECUTED 125c3e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 125c41: c9 leave <== NOT EXECUTED 125c42: c3 ret <== NOT EXECUTED 00125a1c : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 125a1c: 55 push %ebp <== NOT EXECUTED 125a1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125a1f: 57 push %edi <== NOT EXECUTED 125a20: 56 push %esi <== NOT EXECUTED 125a21: 53 push %ebx <== NOT EXECUTED 125a22: 81 ec 9c 00 00 00 sub $0x9c,%esp <== NOT EXECUTED 125a28: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; if ( !print ) 125a2b: 85 ff test %edi,%edi <== NOT EXECUTED 125a2d: 0f 84 c9 00 00 00 je 125afc <== NOT EXECUTED return; (*print)( context, "Period information by period\n" ); 125a33: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 125a36: 68 05 42 14 00 push $0x144205 <== NOT EXECUTED 125a3b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125a3e: ff d7 call *%edi <== NOT EXECUTED #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 125a40: 5e pop %esi <== NOT EXECUTED 125a41: 58 pop %eax <== NOT EXECUTED 125a42: 68 3c 42 14 00 push $0x14423c <== NOT EXECUTED 125a47: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125a4a: ff d7 call *%edi <== NOT EXECUTED #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 125a4c: 59 pop %ecx <== NOT EXECUTED 125a4d: 5b pop %ebx <== NOT EXECUTED 125a4e: 68 60 42 14 00 push $0x144260 <== NOT EXECUTED 125a53: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125a56: ff d7 call *%edi <== NOT EXECUTED Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 125a58: 58 pop %eax <== NOT EXECUTED 125a59: 5a pop %edx <== NOT EXECUTED 125a5a: 68 84 42 14 00 push $0x144284 <== NOT EXECUTED 125a5f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125a62: ff d7 call *%edi <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 125a64: 5b pop %ebx <== NOT EXECUTED 125a65: 5e pop %esi <== NOT EXECUTED 125a66: 68 d0 42 14 00 push $0x1442d0 <== NOT EXECUTED 125a6b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125a6e: ff d7 call *%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 ; 125a70: 8b 35 48 18 16 00 mov 0x161848,%esi <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; 125a76: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125a79: 3b 35 4c 18 16 00 cmp 0x16184c,%esi <== NOT EXECUTED 125a7f: 76 0c jbe 125a8d <== NOT EXECUTED 125a81: eb 79 jmp 125afc <== NOT EXECUTED 125a83: 90 nop <== NOT EXECUTED id++ ) { 125a84: 46 inc %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 ; id <= _Rate_monotonic_Information.maximum_id ; 125a85: 39 35 4c 18 16 00 cmp %esi,0x16184c <== NOT EXECUTED 125a8b: 72 6f jb 125afc <== NOT EXECUTED id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 125a8d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 125a90: 8d 45 90 lea -0x70(%ebp),%eax <== NOT EXECUTED 125a93: 50 push %eax <== NOT EXECUTED 125a94: 56 push %esi <== NOT EXECUTED 125a95: e8 3a 9a 00 00 call 12f4d4 <== NOT EXECUTED if ( status != RTEMS_SUCCESSFUL ) 125a9a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125a9d: 85 c0 test %eax,%eax <== NOT EXECUTED 125a9f: 75 e3 jne 125a84 <== NOT EXECUTED continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 125aa1: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 125aa4: 8d 55 c8 lea -0x38(%ebp),%edx <== NOT EXECUTED 125aa7: 52 push %edx <== NOT EXECUTED 125aa8: 56 push %esi <== NOT EXECUTED 125aa9: e8 82 9a 00 00 call 12f530 <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( status != RTEMS_SUCCESSFUL ) continue; #endif name[ 0 ] = '\0'; 125aae: c6 45 eb 00 movb $0x0,-0x15(%ebp) <== NOT EXECUTED if ( the_status.owner ) { 125ab2: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 125ab5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125ab8: 85 c0 test %eax,%eax <== NOT EXECUTED 125aba: 0f 85 54 01 00 00 jne 125c14 <== NOT EXECUTED 125ac0: 8d 5d eb lea -0x15(%ebp),%ebx <== NOT EXECUTED /* * Print part of report line that is not dependent on granularity */ (*print)( context, 125ac3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 125ac6: ff 75 94 pushl -0x6c(%ebp) <== NOT EXECUTED 125ac9: ff 75 90 pushl -0x70(%ebp) <== NOT EXECUTED 125acc: 53 push %ebx <== NOT EXECUTED 125acd: 56 push %esi <== NOT EXECUTED 125ace: 68 23 42 14 00 push $0x144223 <== NOT EXECUTED 125ad3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125ad6: ff d7 call *%edi <== NOT EXECUTED /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 125ad8: 8b 45 90 mov -0x70(%ebp),%eax <== NOT EXECUTED 125adb: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 125ade: 85 c0 test %eax,%eax <== NOT EXECUTED 125ae0: 75 22 jne 125b04 <== NOT EXECUTED (*print)( context, "\n" ); 125ae2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 125ae5: 68 f4 45 14 00 push $0x1445f4 <== NOT EXECUTED 125aea: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125aed: ff d7 call *%edi <== NOT EXECUTED 125aef: 83 c4 10 add $0x10,%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++ ) { 125af2: 46 inc %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 ; id <= _Rate_monotonic_Information.maximum_id ; 125af3: 39 35 4c 18 16 00 cmp %esi,0x16184c <== NOT EXECUTED 125af9: 73 92 jae 125a8d <== NOT EXECUTED 125afb: 90 nop <== NOT EXECUTED the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 125afc: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 125aff: 5b pop %ebx <== NOT EXECUTED 125b00: 5e pop %esi <== NOT EXECUTED 125b01: 5f pop %edi <== NOT EXECUTED 125b02: c9 leave <== NOT EXECUTED 125b03: c3 ret <== NOT EXECUTED */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 125b04: 52 push %edx <== NOT EXECUTED 125b05: 8d 55 e0 lea -0x20(%ebp),%edx <== NOT EXECUTED 125b08: 52 push %edx <== NOT EXECUTED 125b09: 50 push %eax <== NOT EXECUTED 125b0a: 8d 45 a8 lea -0x58(%ebp),%eax <== NOT EXECUTED 125b0d: 50 push %eax <== NOT EXECUTED 125b0e: e8 1d 15 00 00 call 127030 <_Timespec_Divide_by_integer> <== NOT EXECUTED &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 125b13: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 125b16: bb d3 4d 62 10 mov $0x10624dd3,%ebx <== NOT EXECUTED 125b1b: 89 c8 mov %ecx,%eax <== NOT EXECUTED 125b1d: f7 eb imul %ebx <== NOT EXECUTED 125b1f: 89 45 88 mov %eax,-0x78(%ebp) <== NOT EXECUTED 125b22: 89 55 8c mov %edx,-0x74(%ebp) <== NOT EXECUTED 125b25: 8b 45 8c mov -0x74(%ebp),%eax <== NOT EXECUTED 125b28: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 125b2b: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 125b2e: 29 c8 sub %ecx,%eax <== NOT EXECUTED 125b30: 50 push %eax <== NOT EXECUTED 125b31: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 125b34: 8b 4d a4 mov -0x5c(%ebp),%ecx <== NOT EXECUTED 125b37: 89 c8 mov %ecx,%eax <== NOT EXECUTED 125b39: f7 eb imul %ebx <== NOT EXECUTED 125b3b: 89 45 80 mov %eax,-0x80(%ebp) <== NOT EXECUTED 125b3e: 89 55 84 mov %edx,-0x7c(%ebp) <== NOT EXECUTED 125b41: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 125b44: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 125b47: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 125b4a: 29 c8 sub %ecx,%eax <== NOT EXECUTED 125b4c: 50 push %eax <== NOT EXECUTED 125b4d: ff 75 a0 pushl -0x60(%ebp) <== NOT EXECUTED 125b50: 8b 4d 9c mov -0x64(%ebp),%ecx <== NOT EXECUTED 125b53: 89 c8 mov %ecx,%eax <== NOT EXECUTED 125b55: f7 eb imul %ebx <== NOT EXECUTED 125b57: 89 85 78 ff ff ff mov %eax,-0x88(%ebp) <== NOT EXECUTED 125b5d: 89 95 7c ff ff ff mov %edx,-0x84(%ebp) <== NOT EXECUTED 125b63: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax <== NOT EXECUTED 125b69: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 125b6c: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 125b6f: 29 c8 sub %ecx,%eax <== NOT EXECUTED 125b71: 50 push %eax <== NOT EXECUTED 125b72: ff 75 98 pushl -0x68(%ebp) <== NOT EXECUTED 125b75: 68 1c 43 14 00 push $0x14431c <== NOT EXECUTED 125b7a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125b7d: ff d7 call *%edi <== NOT EXECUTED * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 125b7f: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED 125b82: 8d 55 e0 lea -0x20(%ebp),%edx <== NOT EXECUTED 125b85: 52 push %edx <== NOT EXECUTED 125b86: ff 75 90 pushl -0x70(%ebp) <== NOT EXECUTED 125b89: 8d 45 c0 lea -0x40(%ebp),%eax <== NOT EXECUTED 125b8c: 50 push %eax <== NOT EXECUTED 125b8d: e8 9e 14 00 00 call 127030 <_Timespec_Divide_by_integer> <== NOT EXECUTED &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 125b92: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 125b95: 89 c8 mov %ecx,%eax <== NOT EXECUTED 125b97: f7 eb imul %ebx <== NOT EXECUTED 125b99: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) <== NOT EXECUTED 125b9f: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) <== NOT EXECUTED 125ba5: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax <== NOT EXECUTED 125bab: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 125bae: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 125bb1: 29 c8 sub %ecx,%eax <== NOT EXECUTED 125bb3: 50 push %eax <== NOT EXECUTED 125bb4: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 125bb7: 8b 4d bc mov -0x44(%ebp),%ecx <== NOT EXECUTED 125bba: 89 c8 mov %ecx,%eax <== NOT EXECUTED 125bbc: f7 eb imul %ebx <== NOT EXECUTED 125bbe: 89 85 68 ff ff ff mov %eax,-0x98(%ebp) <== NOT EXECUTED 125bc4: 89 95 6c ff ff ff mov %edx,-0x94(%ebp) <== NOT EXECUTED 125bca: 8b 85 6c ff ff ff mov -0x94(%ebp),%eax <== NOT EXECUTED 125bd0: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 125bd3: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 125bd6: 29 c8 sub %ecx,%eax <== NOT EXECUTED 125bd8: 50 push %eax <== NOT EXECUTED 125bd9: ff 75 b8 pushl -0x48(%ebp) <== NOT EXECUTED 125bdc: 8b 4d b4 mov -0x4c(%ebp),%ecx <== NOT EXECUTED 125bdf: 89 c8 mov %ecx,%eax <== NOT EXECUTED 125be1: f7 eb imul %ebx <== NOT EXECUTED 125be3: 89 85 60 ff ff ff mov %eax,-0xa0(%ebp) <== NOT EXECUTED 125be9: 89 95 64 ff ff ff mov %edx,-0x9c(%ebp) <== NOT EXECUTED 125bef: 8b 85 64 ff ff ff mov -0x9c(%ebp),%eax <== NOT EXECUTED 125bf5: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 125bf8: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 125bfb: 29 c8 sub %ecx,%eax <== NOT EXECUTED 125bfd: 50 push %eax <== NOT EXECUTED 125bfe: ff 75 b0 pushl -0x50(%ebp) <== NOT EXECUTED 125c01: 68 3c 43 14 00 push $0x14433c <== NOT EXECUTED 125c06: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125c09: ff d7 call *%edi <== NOT EXECUTED 125c0b: 83 c4 30 add $0x30,%esp <== NOT EXECUTED 125c0e: e9 71 fe ff ff jmp 125a84 <== NOT EXECUTED 125c13: 90 nop <== NOT EXECUTED #endif name[ 0 ] = '\0'; if ( the_status.owner ) { rtems_object_get_name( the_status.owner, sizeof(name), name ); 125c14: 51 push %ecx <== NOT EXECUTED 125c15: 8d 5d eb lea -0x15(%ebp),%ebx <== NOT EXECUTED 125c18: 53 push %ebx <== NOT EXECUTED 125c19: 6a 05 push $0x5 <== NOT EXECUTED 125c1b: 50 push %eax <== NOT EXECUTED 125c1c: e8 e7 94 fe ff call 10f108 <== NOT EXECUTED 125c21: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125c24: e9 9a fe ff ff jmp 125ac3 <== NOT EXECUTED 00125c44 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 125c44: 55 push %ebp <== NOT EXECUTED 125c45: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125c47: 53 push %ebx <== NOT EXECUTED 125c48: 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 125c4b: a1 18 12 16 00 mov 0x161218,%eax <== NOT EXECUTED 125c50: 40 inc %eax <== NOT EXECUTED 125c51: a3 18 12 16 00 mov %eax,0x161218 <== 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 ; 125c56: 8b 1d 48 18 16 00 mov 0x161848,%ebx <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; 125c5c: 3b 1d 4c 18 16 00 cmp 0x16184c,%ebx <== NOT EXECUTED 125c62: 77 15 ja 125c79 <== NOT EXECUTED id++ ) { status = rtems_rate_monotonic_reset_statistics( id ); 125c64: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125c67: 53 push %ebx <== NOT EXECUTED 125c68: e8 17 00 00 00 call 125c84 <== 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++ ) { 125c6d: 43 inc %ebx <== 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 ; 125c6e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125c71: 39 1d 4c 18 16 00 cmp %ebx,0x16184c <== NOT EXECUTED 125c77: 73 eb jae 125c64 <== NOT EXECUTED /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); } 125c79: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 125c7c: c9 leave <== NOT EXECUTED } /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); 125c7d: e9 52 ba fe ff jmp 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 00125c84 : */ rtems_status_code rtems_rate_monotonic_reset_statistics( Objects_Id id ) { 125c84: 55 push %ebp <== NOT EXECUTED 125c85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125c87: 57 push %edi <== NOT EXECUTED 125c88: 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 125c8b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 125c8e: 50 push %eax <== NOT EXECUTED 125c8f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125c92: 68 40 18 16 00 push $0x161840 <== NOT EXECUTED 125c97: e8 44 b1 fe ff call 110de0 <_Objects_Get> <== NOT EXECUTED 125c9c: 89 c2 mov %eax,%edx <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 125c9e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125ca1: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 125ca4: 85 c0 test %eax,%eax <== NOT EXECUTED 125ca6: 75 34 jne 125cdc <== NOT EXECUTED case OBJECTS_LOCAL: _Rate_monotonic_Reset_statistics( the_period ); 125ca8: 8d 7a 54 lea 0x54(%edx),%edi <== NOT EXECUTED 125cab: b9 38 00 00 00 mov $0x38,%ecx <== NOT EXECUTED 125cb0: 31 c0 xor %eax,%eax <== NOT EXECUTED 125cb2: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 125cb4: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx) <== NOT EXECUTED 125cbb: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx) <== NOT EXECUTED 125cc2: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx) <== NOT EXECUTED 125cc9: c7 42 78 ff ff ff 7f movl $0x7fffffff,0x78(%edx) <== NOT EXECUTED _Thread_Enable_dispatch(); 125cd0: e8 ff b9 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 125cd5: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 125cd7: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 125cda: c9 leave <== NOT EXECUTED 125cdb: c3 ret <== NOT EXECUTED { Objects_Locations location; Rate_monotonic_Control *the_period; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 125cdc: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 125ce1: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 125ce4: c9 leave <== NOT EXECUTED 125ce5: c3 ret <== NOT EXECUTED 001130b8 : uint32_t length, uint32_t page_size, rtems_attribute attribute_set, Objects_Id *id ) { 1130b8: 55 push %ebp <== NOT EXECUTED 1130b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1130bb: 57 push %edi <== NOT EXECUTED 1130bc: 56 push %esi <== NOT EXECUTED 1130bd: 53 push %ebx <== NOT EXECUTED 1130be: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1130c1: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 1130c4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED rtems_status_code return_status; Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 1130c7: 85 ff test %edi,%edi <== NOT EXECUTED 1130c9: 74 25 je 1130f0 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !starting_address ) 1130cb: 85 f6 test %esi,%esi <== NOT EXECUTED 1130cd: 74 0f je 1130de <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !id ) 1130cf: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 1130d2: 85 c0 test %eax,%eax <== NOT EXECUTED 1130d4: 74 08 je 1130de <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) 1130d6: f7 c6 03 00 00 00 test $0x3,%esi <== NOT EXECUTED 1130dc: 74 22 je 113100 <== NOT EXECUTED return_status = RTEMS_SUCCESSFUL; } } _RTEMS_Unlock_allocator(); return return_status; 1130de: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED } 1130e3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1130e5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1130e8: 5b pop %ebx <== NOT EXECUTED 1130e9: 5e pop %esi <== NOT EXECUTED 1130ea: 5f pop %edi <== NOT EXECUTED 1130eb: c9 leave <== NOT EXECUTED 1130ec: c3 ret <== NOT EXECUTED 1130ed: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { rtems_status_code return_status; Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 1130f0: bb 03 00 00 00 mov $0x3,%ebx <== NOT EXECUTED } } _RTEMS_Unlock_allocator(); return return_status; } 1130f5: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1130f7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1130fa: 5b pop %ebx <== NOT EXECUTED 1130fb: 5e pop %esi <== NOT EXECUTED 1130fc: 5f pop %edi <== NOT EXECUTED 1130fd: c9 leave <== NOT EXECUTED 1130fe: c3 ret <== NOT EXECUTED 1130ff: 90 nop <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 113100: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113103: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113109: e8 de 22 00 00 call 1153ec <_API_Mutex_Lock> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 11310e: c7 04 24 80 59 13 00 movl $0x135980,(%esp) <== NOT EXECUTED 113115: e8 4e 35 00 00 call 116668 <_Objects_Allocate> <== NOT EXECUTED 11311a: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_region = _Region_Allocate(); if ( !the_region ) 11311c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11311f: 85 c0 test %eax,%eax <== NOT EXECUTED 113121: 0f 84 9d 00 00 00 je 1131c4 <== NOT EXECUTED return_status = RTEMS_TOO_MANY; else { the_region->maximum_segment_size = _Heap_Initialize( 113127: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 11312a: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 11312d: 56 push %esi <== NOT EXECUTED 11312e: 8d 40 68 lea 0x68(%eax),%eax <== NOT EXECUTED 113131: 50 push %eax <== NOT EXECUTED 113132: e8 5d 30 00 00 call 116194 <_Heap_Initialize> <== NOT EXECUTED 113137: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED &the_region->Memory, starting_address, length, page_size ); if ( !the_region->maximum_segment_size ) { 11313a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11313d: 85 c0 test %eax,%eax <== NOT EXECUTED 11313f: 75 33 jne 113174 <== 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 113141: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 113144: 53 push %ebx <== NOT EXECUTED 113145: 68 80 59 13 00 push $0x135980 <== NOT EXECUTED 11314a: e8 d9 38 00 00 call 116a28 <_Objects_Free> <== NOT EXECUTED 11314f: bb 08 00 00 00 mov $0x8,%ebx <== NOT EXECUTED 113154: 83 c4 10 add $0x10,%esp <== NOT EXECUTED *id = the_region->Object.id; return_status = RTEMS_SUCCESSFUL; } } _RTEMS_Unlock_allocator(); 113157: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11315a: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113160: e8 cf 22 00 00 call 115434 <_API_Mutex_Unlock> <== NOT EXECUTED 113165: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 113168: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11316a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11316d: 5b pop %ebx <== NOT EXECUTED 11316e: 5e pop %esi <== NOT EXECUTED 11316f: 5f pop %edi <== NOT EXECUTED 113170: c9 leave <== NOT EXECUTED 113171: c3 ret <== NOT EXECUTED 113172: 66 90 xchg %ax,%ax <== NOT EXECUTED return_status = RTEMS_INVALID_SIZE; } else { the_region->starting_address = starting_address; 113174: 89 73 50 mov %esi,0x50(%ebx) <== NOT EXECUTED the_region->length = length; 113177: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 11317a: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED the_region->page_size = page_size; 11317d: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 113180: 89 43 58 mov %eax,0x58(%ebx) <== NOT EXECUTED the_region->attribute_set = attribute_set; 113183: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 113186: 89 43 60 mov %eax,0x60(%ebx) <== NOT EXECUTED the_region->number_of_used_blocks = 0; 113189: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) <== NOT EXECUTED _Thread_queue_Initialize( 113190: 6a 06 push $0x6 <== NOT EXECUTED 113192: 6a 40 push $0x40 <== NOT EXECUTED 113194: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED 113197: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 11319a: 50 push %eax <== NOT EXECUTED 11319b: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 11319e: 50 push %eax <== NOT EXECUTED 11319f: e8 70 49 00 00 call 117b14 <_Thread_queue_Initialize> <== NOT EXECUTED 1131a4: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 1131a7: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 1131aa: a1 9c 59 13 00 mov 0x13599c,%eax <== NOT EXECUTED 1131af: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 1131b2: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 1131b5: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 1131b8: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 1131ba: 31 db xor %ebx,%ebx <== NOT EXECUTED 1131bc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1131bf: eb 96 jmp 113157 <== NOT EXECUTED 1131c1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Allocate(); if ( !the_region ) 1131c4: b3 05 mov $0x5,%bl <== NOT EXECUTED 1131c6: eb 8f jmp 113157 <== NOT EXECUTED 001131c8 : */ rtems_status_code rtems_region_delete( Objects_Id id ) { 1131c8: 55 push %ebp <== NOT EXECUTED 1131c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1131cb: 53 push %ebx <== NOT EXECUTED 1131cc: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; _RTEMS_Lock_allocator(); 1131cf: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 1131d5: e8 12 22 00 00 call 1153ec <_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 1131da: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1131dd: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1131e0: 50 push %eax <== NOT EXECUTED 1131e1: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1131e4: 68 80 59 13 00 push $0x135980 <== NOT EXECUTED 1131e9: e8 6e 39 00 00 call 116b5c <_Objects_Get_no_protection> <== NOT EXECUTED 1131ee: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 1131f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1131f3: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 1131f6: 85 c0 test %eax,%eax <== NOT EXECUTED 1131f8: 75 0e jne 113208 <== NOT EXECUTED case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks != 0 ) 1131fa: 8b 4b 64 mov 0x64(%ebx),%ecx <== NOT EXECUTED 1131fd: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1131ff: 74 2f je 113230 <== NOT EXECUTED 113201: bb 0c 00 00 00 mov $0xc,%ebx <== NOT EXECUTED 113206: eb 08 jmp 113210 <== NOT EXECUTED register Region_Control *the_region; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 113208: 48 dec %eax <== NOT EXECUTED 113209: 74 1d je 113228 <== NOT EXECUTED 11320b: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 113210: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113213: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113219: e8 16 22 00 00 call 115434 <_API_Mutex_Unlock> <== NOT EXECUTED return return_status; } 11321e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 113220: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 113223: c9 leave <== NOT EXECUTED 113224: c3 ret <== NOT EXECUTED 113225: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED register Region_Control *the_region; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 113228: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 11322d: eb e1 jmp 113210 <== NOT EXECUTED 11322f: 90 nop <== NOT EXECUTED case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks != 0 ) return_status = RTEMS_RESOURCE_IN_USE; else { _Objects_Close( &_Region_Information, &the_region->Object ); 113230: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 113233: 53 push %ebx <== NOT EXECUTED 113234: 68 80 59 13 00 push $0x135980 <== NOT EXECUTED 113239: e8 aa 34 00 00 call 1166e8 <_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 11323e: 58 pop %eax <== NOT EXECUTED 11323f: 5a pop %edx <== NOT EXECUTED 113240: 53 push %ebx <== NOT EXECUTED 113241: 68 80 59 13 00 push $0x135980 <== NOT EXECUTED 113246: e8 dd 37 00 00 call 116a28 <_Objects_Free> <== NOT EXECUTED 11324b: 31 db xor %ebx,%ebx <== NOT EXECUTED 11324d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113250: eb be jmp 113210 <== NOT EXECUTED 00113254 : rtems_status_code rtems_region_extend( Objects_Id id, void *starting_address, uint32_t length ) { 113254: 55 push %ebp <== NOT EXECUTED 113255: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113257: 56 push %esi <== NOT EXECUTED 113258: 53 push %ebx <== NOT EXECUTED 113259: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 11325c: 8b 75 0c mov 0xc(%ebp),%esi <== 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 ) 11325f: 85 f6 test %esi,%esi <== NOT EXECUTED 113261: 74 79 je 1132dc <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 113263: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113266: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 11326c: e8 7b 21 00 00 call 1153ec <_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 113271: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 113274: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 113277: 50 push %eax <== NOT EXECUTED 113278: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11327b: 68 80 59 13 00 push $0x135980 <== NOT EXECUTED 113280: e8 d7 38 00 00 call 116b5c <_Objects_Get_no_protection> <== NOT EXECUTED 113285: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 113287: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11328a: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11328d: 85 c0 test %eax,%eax <== NOT EXECUTED 11328f: 74 23 je 1132b4 <== NOT EXECUTED 113291: 48 dec %eax <== NOT EXECUTED 113292: 74 58 je 1132ec <== NOT EXECUTED switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; the_region->maximum_segment_size += amount_extended; return_status = RTEMS_SUCCESSFUL; break; 113294: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 113299: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11329c: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 1132a2: e8 8d 21 00 00 call 115434 <_API_Mutex_Unlock> <== NOT EXECUTED 1132a7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 1132aa: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1132ac: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1132af: 5b pop %ebx <== NOT EXECUTED 1132b0: 5e pop %esi <== NOT EXECUTED 1132b1: c9 leave <== NOT EXECUTED 1132b2: c3 ret <== NOT EXECUTED 1132b3: 90 nop <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: heap_status = _Heap_Extend( 1132b4: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1132b7: 50 push %eax <== NOT EXECUTED 1132b8: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1132bb: 56 push %esi <== NOT EXECUTED 1132bc: 8d 43 68 lea 0x68(%ebx),%eax <== NOT EXECUTED 1132bf: 50 push %eax <== NOT EXECUTED 1132c0: e8 f7 2b 00 00 call 115ebc <_Heap_Extend> <== NOT EXECUTED starting_address, length, &amount_extended ); switch ( heap_status ) { 1132c5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1132c8: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 1132cb: 74 27 je 1132f4 <== NOT EXECUTED 1132cd: 73 2d jae 1132fc <== NOT EXECUTED case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 1132cf: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 1132d2: 01 43 54 add %eax,0x54(%ebx) <== NOT EXECUTED the_region->maximum_segment_size += amount_extended; 1132d5: 01 43 5c add %eax,0x5c(%ebx) <== NOT EXECUTED 1132d8: 31 db xor %ebx,%ebx <== NOT EXECUTED 1132da: eb bd jmp 113299 <== 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 ) 1132dc: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED break; } _RTEMS_Unlock_allocator(); return return_status; } 1132e1: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1132e3: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1132e6: 5b pop %ebx <== NOT EXECUTED 1132e7: 5e pop %esi <== NOT EXECUTED 1132e8: c9 leave <== NOT EXECUTED 1132e9: c3 ret <== NOT EXECUTED 1132ea: 66 90 xchg %ax,%ax <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Get( id, &location ); switch ( location ) { 1132ec: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 1132f1: eb a6 jmp 113299 <== NOT EXECUTED 1132f3: 90 nop <== NOT EXECUTED starting_address, length, &amount_extended ); switch ( heap_status ) { 1132f4: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED 1132f9: eb 9e jmp 113299 <== NOT EXECUTED 1132fb: 90 nop <== NOT EXECUTED 1132fc: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 1132ff: 75 93 jne 113294 <== NOT EXECUTED case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; the_region->maximum_segment_size += amount_extended; return_status = RTEMS_SUCCESSFUL; break; 113301: bb 18 00 00 00 mov $0x18,%ebx <== NOT EXECUTED 113306: eb 91 jmp 113299 <== NOT EXECUTED 00113308 : rtems_status_code rtems_region_get_free_information( Objects_Id id, Heap_Information_block *the_info ) { 113308: 55 push %ebp <== NOT EXECUTED 113309: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11330b: 53 push %ebx <== NOT EXECUTED 11330c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 11330f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !the_info ) 113312: 85 db test %ebx,%ebx <== NOT EXECUTED 113314: 74 7a je 113390 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 113316: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113319: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 11331f: e8 c8 20 00 00 call 1153ec <_API_Mutex_Lock> <== NOT EXECUTED 113324: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 113327: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 11332a: 50 push %eax <== NOT EXECUTED 11332b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11332e: 68 80 59 13 00 push $0x135980 <== NOT EXECUTED 113333: e8 24 38 00 00 call 116b5c <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 113338: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11333b: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 11333e: 85 d2 test %edx,%edx <== NOT EXECUTED 113340: 74 22 je 113364 <== NOT EXECUTED 113342: 4a dec %edx <== NOT EXECUTED 113343: 74 57 je 11339c <== NOT EXECUTED 113345: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 11334a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11334d: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113353: e8 dc 20 00 00 call 115434 <_API_Mutex_Unlock> <== NOT EXECUTED 113358: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 11335b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11335d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 113360: c9 leave <== NOT EXECUTED 113361: c3 ret <== NOT EXECUTED 113362: 66 90 xchg %ax,%ax <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: the_info->Used.number = 0; 113364: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED the_info->Used.total = 0; 11336b: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) <== NOT EXECUTED the_info->Used.largest = 0; 113372: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED _Heap_Get_free_information( &the_region->Memory, &the_info->Free ); 113379: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11337c: 53 push %ebx <== NOT EXECUTED 11337d: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 113380: 50 push %eax <== NOT EXECUTED 113381: e8 3a 2d 00 00 call 1160c0 <_Heap_Get_free_information> <== NOT EXECUTED 113386: 31 db xor %ebx,%ebx <== NOT EXECUTED 113388: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11338b: eb bd jmp 11334a <== NOT EXECUTED 11338d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !the_info ) 113390: b3 09 mov $0x9,%bl <== NOT EXECUTED break; } _RTEMS_Unlock_allocator(); return return_status; } 113392: 89 d8 mov %ebx,%eax <== NOT EXECUTED 113394: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 113397: c9 leave <== NOT EXECUTED 113398: c3 ret <== NOT EXECUTED 113399: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 11339c: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 1133a1: eb a7 jmp 11334a <== NOT EXECUTED 001133a4 : rtems_status_code rtems_region_get_information( Objects_Id id, Heap_Information_block *the_info ) { 1133a4: 55 push %ebp <== NOT EXECUTED 1133a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1133a7: 53 push %ebx <== NOT EXECUTED 1133a8: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 1133ab: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !the_info ) 1133ae: 85 db test %ebx,%ebx <== NOT EXECUTED 1133b0: 74 6a je 11341c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 1133b2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1133b5: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 1133bb: e8 2c 20 00 00 call 1153ec <_API_Mutex_Lock> <== NOT EXECUTED 1133c0: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1133c3: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1133c6: 50 push %eax <== NOT EXECUTED 1133c7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1133ca: 68 80 59 13 00 push $0x135980 <== NOT EXECUTED 1133cf: e8 88 37 00 00 call 116b5c <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 1133d4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1133d7: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 1133da: 85 d2 test %edx,%edx <== NOT EXECUTED 1133dc: 74 22 je 113400 <== NOT EXECUTED 1133de: 4a dec %edx <== NOT EXECUTED 1133df: 74 47 je 113428 <== NOT EXECUTED 1133e1: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 1133e6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1133e9: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 1133ef: e8 40 20 00 00 call 115434 <_API_Mutex_Unlock> <== NOT EXECUTED 1133f4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 1133f7: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1133f9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1133fc: c9 leave <== NOT EXECUTED 1133fd: c3 ret <== NOT EXECUTED 1133fe: 66 90 xchg %ax,%ax <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _Heap_Get_information( &the_region->Memory, the_info ) != 113400: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 113403: 53 push %ebx <== NOT EXECUTED 113404: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 113407: 50 push %eax <== NOT EXECUTED 113408: e8 fb 2c 00 00 call 116108 <_Heap_Get_information> <== NOT EXECUTED 11340d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113410: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 113413: 19 db sbb %ebx,%ebx <== NOT EXECUTED 113415: f7 d3 not %ebx <== NOT EXECUTED 113417: 83 e3 09 and $0x9,%ebx <== NOT EXECUTED 11341a: eb ca jmp 1133e6 <== NOT EXECUTED { Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !the_info ) 11341c: b3 09 mov $0x9,%bl <== NOT EXECUTED break; } _RTEMS_Unlock_allocator(); return return_status; } 11341e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 113420: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 113423: c9 leave <== NOT EXECUTED 113424: c3 ret <== NOT EXECUTED 113425: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 113428: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 11342d: eb b7 jmp 1133e6 <== NOT EXECUTED 00113430 : uint32_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 113430: 55 push %ebp <== NOT EXECUTED 113431: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113433: 57 push %edi <== NOT EXECUTED 113434: 56 push %esi <== NOT EXECUTED 113435: 53 push %ebx <== NOT EXECUTED 113436: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 113439: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 11343c: 8b 5d 18 mov 0x18(%ebp),%ebx <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; void *the_segment; if ( !segment ) 11343f: 85 db test %ebx,%ebx <== NOT EXECUTED 113441: 0f 84 89 00 00 00 je 1134d0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; *segment = NULL; 113447: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED if ( size == 0 ) 11344d: 85 f6 test %esi,%esi <== NOT EXECUTED 11344f: 75 0f jne 113460 <== NOT EXECUTED 113451: bb 08 00 00 00 mov $0x8,%ebx <== NOT EXECUTED break; } _RTEMS_Unlock_allocator(); return return_status; } 113456: 89 d8 mov %ebx,%eax <== NOT EXECUTED 113458: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11345b: 5b pop %ebx <== NOT EXECUTED 11345c: 5e pop %esi <== NOT EXECUTED 11345d: 5f pop %edi <== NOT EXECUTED 11345e: c9 leave <== NOT EXECUTED 11345f: c3 ret <== NOT EXECUTED *segment = NULL; if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 113460: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113463: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113469: e8 7e 1f 00 00 call 1153ec <_API_Mutex_Lock> <== NOT EXECUTED executing = _Thread_Executing; 11346e: a1 bc 5b 13 00 mov 0x135bbc,%eax <== NOT EXECUTED 113473: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 113476: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 113479: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 11347c: 50 push %eax <== NOT EXECUTED 11347d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 113480: 68 80 59 13 00 push $0x135980 <== NOT EXECUTED 113485: e8 d2 36 00 00 call 116b5c <_Objects_Get_no_protection> <== NOT EXECUTED 11348a: 89 c7 mov %eax,%edi <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 11348c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11348f: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 113492: 85 c0 test %eax,%eax <== NOT EXECUTED 113494: 74 26 je 1134bc <== NOT EXECUTED 113496: 48 dec %eax <== NOT EXECUTED 113497: 74 2f je 1134c8 <== NOT EXECUTED 113499: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 11349e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1134a1: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 1134a7: e8 88 1f 00 00 call 115434 <_API_Mutex_Unlock> <== NOT EXECUTED 1134ac: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 1134af: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1134b1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1134b4: 5b pop %ebx <== NOT EXECUTED 1134b5: 5e pop %esi <== NOT EXECUTED 1134b6: 5f pop %edi <== NOT EXECUTED 1134b7: c9 leave <== NOT EXECUTED 1134b8: c3 ret <== NOT EXECUTED 1134b9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED executing = _Thread_Executing; the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( size > the_region->maximum_segment_size ) 1134bc: 3b 77 5c cmp 0x5c(%edi),%esi <== NOT EXECUTED 1134bf: 76 13 jbe 1134d4 <== NOT EXECUTED 1134c1: bb 08 00 00 00 mov $0x8,%ebx <== NOT EXECUTED 1134c6: eb d6 jmp 11349e <== NOT EXECUTED _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); _Thread_Enable_dispatch(); return (rtems_status_code) executing->Wait.return_code; 1134c8: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 1134cd: eb cf jmp 11349e <== NOT EXECUTED 1134cf: 90 nop <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; void *the_segment; if ( !segment ) 1134d0: b3 09 mov $0x9,%bl <== NOT EXECUTED 1134d2: eb 82 jmp 113456 <== 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. * 1134d4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1134d7: 56 push %esi <== NOT EXECUTED 1134d8: 8d 47 68 lea 0x68(%edi),%eax <== NOT EXECUTED 1134db: 50 push %eax <== NOT EXECUTED 1134dc: e8 47 29 00 00 call 115e28 <_Heap_Allocate> <== NOT EXECUTED the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 1134e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1134e4: 85 c0 test %eax,%eax <== NOT EXECUTED 1134e6: 74 09 je 1134f1 <== NOT EXECUTED the_region->number_of_used_blocks += 1; 1134e8: ff 47 64 incl 0x64(%edi) <== NOT EXECUTED *segment = the_segment; 1134eb: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 1134ed: 31 db xor %ebx,%ebx <== NOT EXECUTED 1134ef: eb ad jmp 11349e <== NOT EXECUTED return_status = RTEMS_SUCCESSFUL; } else if ( _Options_Is_no_wait( option_set ) ) { 1134f1: f6 45 10 01 testb $0x1,0x10(%ebp) <== NOT EXECUTED 1134f5: 74 07 je 1134fe <== NOT EXECUTED 1134f7: bb 0d 00 00 00 mov $0xd,%ebx <== NOT EXECUTED 1134fc: eb a0 jmp 11349e <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1134fe: a1 f8 5a 13 00 mov 0x135af8,%eax <== NOT EXECUTED 113503: 40 inc %eax <== NOT EXECUTED 113504: a3 f8 5a 13 00 mov %eax,0x135af8 <== 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(); 113509: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11350c: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113512: e8 1d 1f 00 00 call 115434 <_API_Mutex_Unlock> <== NOT EXECUTED executing->Wait.queue = &the_region->Wait_queue; 113517: 8d 47 10 lea 0x10(%edi),%eax <== NOT EXECUTED 11351a: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 11351d: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED executing->Wait.id = id; 113520: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 113523: 89 4a 20 mov %ecx,0x20(%edx) <== NOT EXECUTED executing->Wait.count = size; 113526: 89 72 24 mov %esi,0x24(%edx) <== NOT EXECUTED executing->Wait.return_argument = segment; 113529: 89 5a 28 mov %ebx,0x28(%edx) <== 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 11352c: c7 47 40 01 00 00 00 movl $0x1,0x40(%edi) <== NOT EXECUTED _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 113533: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 113536: 68 f0 7b 11 00 push $0x117bf0 <== NOT EXECUTED 11353b: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 11353e: 50 push %eax <== NOT EXECUTED 11353f: e8 5c 43 00 00 call 1178a0 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 113544: e8 97 3e 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED return (rtems_status_code) executing->Wait.return_code; 113549: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 11354c: 8b 58 34 mov 0x34(%eax),%ebx <== NOT EXECUTED 11354f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113552: e9 ff fe ff ff jmp 113456 <== NOT EXECUTED 00113558 : rtems_status_code rtems_region_get_segment_size( Objects_Id id, void *segment, size_t *size ) { 113558: 55 push %ebp <== NOT EXECUTED 113559: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11355b: 56 push %esi <== NOT EXECUTED 11355c: 53 push %ebx <== NOT EXECUTED 11355d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 113560: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 113563: 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 ) 113566: 85 f6 test %esi,%esi <== NOT EXECUTED 113568: 74 6a je 1135d4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !size ) 11356a: 85 db test %ebx,%ebx <== NOT EXECUTED 11356c: 74 66 je 1135d4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 11356e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113571: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113577: e8 70 1e 00 00 call 1153ec <_API_Mutex_Lock> <== NOT EXECUTED * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 11357c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 11357f: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 113582: 50 push %eax <== NOT EXECUTED 113583: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 113586: 68 80 59 13 00 push $0x135980 <== NOT EXECUTED 11358b: e8 cc 35 00 00 call 116b5c <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 113590: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113593: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 113596: 85 d2 test %edx,%edx <== NOT EXECUTED 113598: 74 22 je 1135bc <== NOT EXECUTED 11359a: 4a dec %edx <== NOT EXECUTED 11359b: 74 47 je 1135e4 <== NOT EXECUTED 11359d: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 1135a2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1135a5: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 1135ab: e8 84 1e 00 00 call 115434 <_API_Mutex_Unlock> <== NOT EXECUTED 1135b0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 1135b3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1135b5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1135b8: 5b pop %ebx <== NOT EXECUTED 1135b9: 5e pop %esi <== NOT EXECUTED 1135ba: c9 leave <== NOT EXECUTED 1135bb: c3 ret <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Heap_Size_of_user_area( &the_region->Memory, segment, size ) ) 1135bc: 52 push %edx <== NOT EXECUTED 1135bd: 53 push %ebx <== NOT EXECUTED 1135be: 56 push %esi <== NOT EXECUTED 1135bf: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 1135c2: 50 push %eax <== NOT EXECUTED 1135c3: e8 a0 2f 00 00 call 116568 <_Heap_Size_of_user_area> <== NOT EXECUTED 1135c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1135cb: 3c 01 cmp $0x1,%al <== NOT EXECUTED 1135cd: 19 db sbb %ebx,%ebx <== NOT EXECUTED 1135cf: 83 e3 09 and $0x9,%ebx <== NOT EXECUTED 1135d2: eb ce jmp 1135a2 <== NOT EXECUTED return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); return return_status; 1135d4: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED } 1135d9: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1135db: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1135de: 5b pop %ebx <== NOT EXECUTED 1135df: 5e pop %esi <== NOT EXECUTED 1135e0: c9 leave <== NOT EXECUTED 1135e1: c3 ret <== NOT EXECUTED 1135e2: 66 90 xchg %ax,%ax <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 1135e4: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 1135e9: eb b7 jmp 1135a2 <== NOT EXECUTED 001135ec : rtems_status_code rtems_region_ident( rtems_name name, Objects_Id *id ) { 1135ec: 55 push %ebp <== NOT EXECUTED 1135ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1135ef: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 1135f2: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1135f5: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 1135fa: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1135fd: 68 80 59 13 00 push $0x135980 <== NOT EXECUTED 113602: e8 ed 36 00 00 call 116cf4 <_Objects_Name_to_id_u32> <== NOT EXECUTED 113607: 8b 04 85 8c a7 12 00 mov 0x12a78c(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 11360e: c9 leave <== NOT EXECUTED 11360f: c3 ret <== NOT EXECUTED 00113610 : Objects_Id id, void *segment, size_t size, size_t *old_size ) { 113610: 55 push %ebp <== NOT EXECUTED 113611: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113613: 57 push %edi <== NOT EXECUTED 113614: 56 push %esi <== NOT EXECUTED 113615: 53 push %ebx <== NOT EXECUTED 113616: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 113619: 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 ) 11361c: 85 ff test %edi,%edi <== NOT EXECUTED 11361e: 0f 84 bc 00 00 00 je 1136e0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 113624: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113627: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 11362d: e8 ba 1d 00 00 call 1153ec <_API_Mutex_Lock> <== NOT EXECUTED 113632: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 113635: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 113638: 50 push %eax <== NOT EXECUTED 113639: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11363c: 68 80 59 13 00 push $0x135980 <== NOT EXECUTED 113641: e8 16 35 00 00 call 116b5c <_Objects_Get_no_protection> <== NOT EXECUTED 113646: 89 c6 mov %eax,%esi <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 113648: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11364b: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11364e: 85 c0 test %eax,%eax <== NOT EXECUTED 113650: 74 2a je 11367c <== NOT EXECUTED 113652: 48 dec %eax <== NOT EXECUTED 113653: 0f 84 97 00 00 00 je 1136f0 <== NOT EXECUTED 113659: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 11365e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113661: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113667: e8 c8 1d 00 00 call 115434 <_API_Mutex_Unlock> <== NOT EXECUTED 11366c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 11366f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 113671: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 113674: 5b pop %ebx <== NOT EXECUTED 113675: 5e pop %esi <== NOT EXECUTED 113676: 5f pop %edi <== NOT EXECUTED 113677: c9 leave <== NOT EXECUTED 113678: c3 ret <== NOT EXECUTED 113679: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 7 ); status = _Heap_Resize_block( 11367c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11367f: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 113682: 50 push %eax <== NOT EXECUTED 113683: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 113686: 50 push %eax <== NOT EXECUTED 113687: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 11368a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11368d: 8d 46 68 lea 0x68(%esi),%eax <== NOT EXECUTED 113690: 50 push %eax <== NOT EXECUTED 113691: e8 e6 2c 00 00 call 11637c <_Heap_Resize_block> <== NOT EXECUTED 113696: 89 c3 mov %eax,%ebx <== NOT EXECUTED segment, (uint32_t) size, &osize, &avail_size ); *old_size = (uint32_t) osize; 113698: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 11369b: 89 07 mov %eax,(%edi) <== NOT EXECUTED _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 ) 11369d: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1136a0: 85 db test %ebx,%ebx <== NOT EXECUTED 1136a2: 75 24 jne 1136c8 <== NOT EXECUTED 1136a4: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1136a7: 85 c0 test %eax,%eax <== NOT EXECUTED 1136a9: 75 51 jne 1136fc <== NOT EXECUTED _Region_Process_queue( the_region ); /* unlocks allocator */ else _RTEMS_Unlock_allocator(); 1136ab: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1136ae: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 1136b4: e8 7b 1d 00 00 call 115434 <_API_Mutex_Unlock> <== NOT EXECUTED 1136b9: 31 db xor %ebx,%ebx <== NOT EXECUTED 1136bb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } _RTEMS_Unlock_allocator(); return return_status; } 1136be: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1136c0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1136c3: 5b pop %ebx <== NOT EXECUTED 1136c4: 5e pop %esi <== NOT EXECUTED 1136c5: 5f pop %edi <== NOT EXECUTED 1136c6: c9 leave <== NOT EXECUTED 1136c7: c3 ret <== NOT EXECUTED _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 ) _Region_Process_queue( the_region ); /* unlocks allocator */ else _RTEMS_Unlock_allocator(); 1136c8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1136cb: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 1136d1: e8 5e 1d 00 00 call 115434 <_API_Mutex_Unlock> <== NOT EXECUTED return 1136d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1136d9: 83 fb 01 cmp $0x1,%ebx <== NOT EXECUTED 1136dc: 74 32 je 113710 <== NOT EXECUTED 1136de: 66 90 xchg %ax,%ax <== NOT EXECUTED return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); return return_status; 1136e0: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED } 1136e5: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1136e7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1136ea: 5b pop %ebx <== NOT EXECUTED 1136eb: 5e pop %esi <== NOT EXECUTED 1136ec: 5f pop %edi <== NOT EXECUTED 1136ed: c9 leave <== NOT EXECUTED 1136ee: c3 ret <== NOT EXECUTED 1136ef: 90 nop <== NOT EXECUTED if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 ) _Region_Process_queue( the_region ); /* unlocks allocator */ else _RTEMS_Unlock_allocator(); return 1136f0: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 1136f5: e9 64 ff ff ff jmp 11365e <== NOT EXECUTED 1136fa: 66 90 xchg %ax,%ax <== NOT EXECUTED *old_size = (uint32_t) osize; _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 ) _Region_Process_queue( the_region ); /* unlocks allocator */ 1136fc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1136ff: 56 push %esi <== NOT EXECUTED 113700: e8 47 6b 00 00 call 11a24c <_Region_Process_queue> <== NOT EXECUTED 113705: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113708: e9 62 ff ff ff jmp 11366f <== NOT EXECUTED 11370d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED else _RTEMS_Unlock_allocator(); return 113710: b3 0d mov $0xd,%bl <== NOT EXECUTED 113712: e9 58 ff ff ff jmp 11366f <== NOT EXECUTED 00113718 : rtems_status_code rtems_region_return_segment( Objects_Id id, void *segment ) { 113718: 55 push %ebp <== NOT EXECUTED 113719: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11371b: 53 push %ebx <== NOT EXECUTED 11371c: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED uint32_t size; #endif int status; register Region_Control *the_region; _RTEMS_Lock_allocator(); 11371f: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113725: e8 c2 1c 00 00 call 1153ec <_API_Mutex_Lock> <== NOT EXECUTED 11372a: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 11372d: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 113730: 50 push %eax <== NOT EXECUTED 113731: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 113734: 68 80 59 13 00 push $0x135980 <== NOT EXECUTED 113739: e8 1e 34 00 00 call 116b5c <_Objects_Get_no_protection> <== NOT EXECUTED 11373e: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 113740: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113743: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 113746: 85 c0 test %eax,%eax <== NOT EXECUTED 113748: 75 1e jne 113768 <== 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. 11374a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11374d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 113750: 8d 43 68 lea 0x68(%ebx),%eax <== NOT EXECUTED 113753: 50 push %eax <== NOT EXECUTED 113754: e8 07 28 00 00 call 115f60 <_Heap_Free> <== NOT EXECUTED #endif status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) 113759: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11375c: 84 c0 test %al,%al <== NOT EXECUTED 11375e: 75 30 jne 113790 <== NOT EXECUTED else { the_region->number_of_used_blocks -= 1; _Region_Process_queue(the_region); /* unlocks allocator */ return RTEMS_SUCCESSFUL; 113760: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED 113765: eb 09 jmp 113770 <== NOT EXECUTED 113767: 90 nop <== NOT EXECUTED register Region_Control *the_region; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 113768: 48 dec %eax <== NOT EXECUTED 113769: 74 1d je 113788 <== NOT EXECUTED 11376b: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 113770: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113773: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113779: e8 b6 1c 00 00 call 115434 <_API_Mutex_Unlock> <== NOT EXECUTED 11377e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 113781: 89 d8 mov %ebx,%eax <== NOT EXECUTED 113783: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 113786: c9 leave <== NOT EXECUTED 113787: c3 ret <== NOT EXECUTED register Region_Control *the_region; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 113788: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 11378d: eb e1 jmp 113770 <== NOT EXECUTED 11378f: 90 nop <== NOT EXECUTED if ( !status ) return_status = RTEMS_INVALID_ADDRESS; else { the_region->number_of_used_blocks -= 1; 113790: ff 4b 64 decl 0x64(%ebx) <== NOT EXECUTED _Region_Process_queue(the_region); /* unlocks allocator */ 113793: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113796: 53 push %ebx <== NOT EXECUTED 113797: e8 b0 6a 00 00 call 11a24c <_Region_Process_queue> <== NOT EXECUTED 11379c: 31 db xor %ebx,%ebx <== NOT EXECUTED 11379e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1137a1: eb de jmp 113781 <== NOT EXECUTED 0010a12c : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 10a12c: 55 push %ebp <== NOT EXECUTED 10a12d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a12f: 57 push %edi <== NOT EXECUTED 10a130: 56 push %esi <== NOT EXECUTED 10a131: 53 push %ebx <== NOT EXECUTED 10a132: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 10a135: 8b 7d 08 mov 0x8(%ebp),%edi <== 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 ) ) 10a138: 85 ff test %edi,%edi <== NOT EXECUTED 10a13a: 74 64 je 10a1a0 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 10a13c: 8b 4d 18 mov 0x18(%ebp),%ecx <== NOT EXECUTED 10a13f: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a141: 0f 84 01 01 00 00 je 10a248 <== NOT EXECUTED return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 10a147: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10a14a: 25 c0 00 00 00 and $0xc0,%eax <== NOT EXECUTED 10a14f: 74 1f je 10a170 <== 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, 10a151: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10a154: 83 e3 30 and $0x30,%ebx <== NOT EXECUTED _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 10a157: 83 fb 10 cmp $0x10,%ebx <== NOT EXECUTED 10a15a: 74 34 je 10a190 <== NOT EXECUTED 10a15c: 83 fb 20 cmp $0x20,%ebx <== NOT EXECUTED 10a15f: 74 2f je 10a190 <== NOT EXECUTED name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 10a161: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED } 10a166: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a169: 5b pop %ebx <== NOT EXECUTED 10a16a: 5e pop %esi <== NOT EXECUTED 10a16b: 5f pop %edi <== NOT EXECUTED 10a16c: c9 leave <== NOT EXECUTED 10a16d: c3 ret <== NOT EXECUTED 10a16e: 66 90 xchg %ax,%ax <== NOT EXECUTED return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 10a170: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10a173: 83 e3 30 and $0x30,%ebx <== NOT EXECUTED if ( _Attributes_Is_inherit_priority( attribute_set ) && _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) ) 10a176: 85 db test %ebx,%ebx <== NOT EXECUTED 10a178: 74 36 je 10a1b0 <== NOT EXECUTED 10a17a: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10a17e: 76 30 jbe 10a1b0 <== NOT EXECUTED 10a180: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10a185: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a188: 5b pop %ebx <== NOT EXECUTED 10a189: 5e pop %esi <== NOT EXECUTED 10a18a: 5f pop %edi <== NOT EXECUTED 10a18b: c9 leave <== NOT EXECUTED 10a18c: c3 ret <== NOT EXECUTED 10a18d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 10a190: f6 45 10 04 testb $0x4,0x10(%ebp) <== NOT EXECUTED 10a194: 74 cb je 10a161 <== NOT EXECUTED _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 10a196: 3d c0 00 00 00 cmp $0xc0,%eax <== NOT EXECUTED 10a19b: 75 d9 jne 10a176 <== NOT EXECUTED 10a19d: eb c2 jmp 10a161 <== NOT EXECUTED 10a19f: 90 nop <== 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 ) ) 10a1a0: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10a1a5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a1a8: 5b pop %ebx <== NOT EXECUTED 10a1a9: 5e pop %esi <== NOT EXECUTED 10a1aa: 5f pop %edi <== NOT EXECUTED 10a1ab: c9 leave <== NOT EXECUTED 10a1ac: c3 ret <== NOT EXECUTED 10a1ad: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a1b0: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10a1b5: 40 inc %eax <== NOT EXECUTED 10a1b6: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 10a1bb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a1be: 68 40 e9 11 00 push $0x11e940 <== NOT EXECUTED 10a1c3: e8 a8 13 00 00 call 10b570 <_Objects_Allocate> <== NOT EXECUTED 10a1c8: 89 c6 mov %eax,%esi <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 10a1ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a1cd: 85 c0 test %eax,%eax <== NOT EXECUTED 10a1cf: 0f 84 eb 00 00 00 je 10a2c0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_semaphore->attribute_set = attribute_set; 10a1d5: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10a1d8: 89 46 10 mov %eax,0x10(%esi) <== 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 ) ) { 10a1db: 85 db test %ebx,%ebx <== NOT EXECUTED 10a1dd: 74 75 je 10a254 <== NOT EXECUTED CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) 10a1df: a8 40 test $0x40,%al <== NOT EXECUTED 10a1e1: 0f 84 c5 00 00 00 je 10a2ac <== NOT EXECUTED the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 10a1e7: c7 45 e4 02 00 00 00 movl $0x2,-0x1c(%ebp) <== NOT EXECUTED the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; else the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 10a1ee: 83 fb 10 cmp $0x10,%ebx <== NOT EXECUTED 10a1f1: 0f 84 d9 00 00 00 je 10a2d0 <== NOT EXECUTED case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_mutex_attributes.only_owner_release = TRUE; break; } } else { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS; 10a1f7: c7 45 dc 02 00 00 00 movl $0x2,-0x24(%ebp) <== NOT EXECUTED the_mutex_attributes.only_owner_release = FALSE; 10a1fe: c6 45 e0 00 movb $0x0,-0x20(%ebp) <== NOT EXECUTED } the_mutex_attributes.priority_ceiling = priority_ceiling; 10a202: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a205: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED mutex_status = _CORE_mutex_Initialize( 10a208: 52 push %edx <== NOT EXECUTED 10a209: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a20b: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10a20f: 0f 94 c0 sete %al <== NOT EXECUTED 10a212: 50 push %eax <== NOT EXECUTED 10a213: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 10a216: 50 push %eax <== NOT EXECUTED 10a217: 8d 46 14 lea 0x14(%esi),%eax <== NOT EXECUTED 10a21a: 50 push %eax <== NOT EXECUTED 10a21b: e8 a0 0c 00 00 call 10aec0 <_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 ) { 10a220: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a223: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 10a226: 75 61 jne 10a289 <== 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 10a228: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a22b: 56 push %esi <== NOT EXECUTED 10a22c: 68 40 e9 11 00 push $0x11e940 <== NOT EXECUTED 10a231: e8 fa 16 00 00 call 10b930 <_Objects_Free> <== NOT EXECUTED _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 10a236: e8 6d 20 00 00 call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a23b: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED 10a240: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a243: e9 1e ff ff ff jmp 10a166 <== NOT EXECUTED CORE_semaphore_Attributes the_semaphore_attributes; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 10a248: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a24d: e9 14 ff ff ff jmp 10a166 <== NOT EXECUTED 10a252: 66 90 xchg %ax,%ax <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INVALID_PRIORITY; } } else { if ( _Attributes_Is_priority( attribute_set ) ) the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 10a254: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a256: f6 45 10 04 testb $0x4,0x10(%ebp) <== NOT EXECUTED 10a25a: 0f 95 c0 setne %al <== NOT EXECUTED 10a25d: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 10a260: 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; 10a267: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM; 10a26e: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp) <== NOT EXECUTED _CORE_semaphore_Initialize( 10a275: 50 push %eax <== NOT EXECUTED 10a276: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a279: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10a27c: 50 push %eax <== NOT EXECUTED 10a27d: 8d 46 14 lea 0x14(%esi),%eax <== NOT EXECUTED 10a280: 50 push %eax <== NOT EXECUTED 10a281: e8 f2 0e 00 00 call 10b178 <_CORE_semaphore_Initialize> <== NOT EXECUTED 10a286: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a289: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED 10a28c: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10a28f: a1 5c e9 11 00 mov 0x11e95c,%eax <== NOT EXECUTED 10a294: 89 34 90 mov %esi,(%eax,%edx,4) <== NOT EXECUTED 10a297: 89 7e 0c mov %edi,0xc(%esi) <== NOT EXECUTED &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 10a29a: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10a29d: 89 08 mov %ecx,(%eax) <== NOT EXECUTED the_semaphore->Object.id, name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 10a29f: e8 04 20 00 00 call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a2a4: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a2a6: e9 bb fe ff ff jmp 10a166 <== NOT EXECUTED 10a2ab: 90 nop <== NOT EXECUTED if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) { CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) 10a2ac: 80 7d 10 00 cmpb $0x0,0x10(%ebp) <== NOT EXECUTED 10a2b0: 79 43 jns 10a2f5 <== NOT EXECUTED the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 10a2b2: c7 45 e4 03 00 00 00 movl $0x3,-0x1c(%ebp) <== NOT EXECUTED 10a2b9: e9 30 ff ff ff jmp 10a1ee <== NOT EXECUTED 10a2be: 66 90 xchg %ax,%ax <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { _Thread_Enable_dispatch(); 10a2c0: e8 e3 1f 00 00 call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a2c5: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10a2ca: e9 97 fe ff ff jmp 10a166 <== NOT EXECUTED 10a2cf: 90 nop <== NOT EXECUTED else the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 10a2d0: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED switch ( the_mutex_attributes.discipline ) { 10a2d7: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10a2da: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10a2dd: 0f 86 1b ff ff ff jbe 10a1fe <== NOT EXECUTED 10a2e3: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10a2e6: 0f 87 16 ff ff ff ja 10a202 <== 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; 10a2ec: c6 45 e0 01 movb $0x1,-0x20(%ebp) <== NOT EXECUTED 10a2f0: e9 0d ff ff ff jmp 10a202 <== NOT EXECUTED if ( _Attributes_Is_inherit_priority( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; else if ( _Attributes_Is_priority( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; 10a2f5: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a2f7: f6 45 10 04 testb $0x4,0x10(%ebp) <== NOT EXECUTED 10a2fb: 0f 95 c0 setne %al <== NOT EXECUTED 10a2fe: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED 10a301: e9 e8 fe ff ff jmp 10a1ee <== NOT EXECUTED 0010a308 : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 10a308: 55 push %ebp <== NOT EXECUTED 10a309: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a30b: 53 push %ebx <== NOT EXECUTED 10a30c: 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 10a30f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a312: 50 push %eax <== NOT EXECUTED 10a313: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a316: 68 40 e9 11 00 push $0x11e940 <== NOT EXECUTED 10a31b: e8 44 17 00 00 call 10ba64 <_Objects_Get> <== NOT EXECUTED 10a320: 89 c3 mov %eax,%ebx <== NOT EXECUTED register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 10a322: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a325: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 10a328: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a32a: 74 0c je 10a338 <== NOT EXECUTED 10a32c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a331: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a334: c9 leave <== NOT EXECUTED 10a335: c3 ret <== NOT EXECUTED 10a336: 66 90 xchg %ax,%ax <== 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. * 10a338: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 10a33b: 83 e0 30 and $0x30,%eax <== NOT EXECUTED 10a33e: 74 58 je 10a398 <== NOT EXECUTED if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 10a340: 8b 53 64 mov 0x64(%ebx),%edx <== NOT EXECUTED 10a343: 85 d2 test %edx,%edx <== NOT EXECUTED 10a345: 75 15 jne 10a35c <== NOT EXECUTED 10a347: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED 10a34a: 74 10 je 10a35c <== NOT EXECUTED !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); 10a34c: e8 57 1f 00 00 call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a351: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a356: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a359: c9 leave <== NOT EXECUTED 10a35a: c3 ret <== NOT EXECUTED 10a35b: 90 nop <== NOT EXECUTED !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } _CORE_mutex_Flush( 10a35c: 50 push %eax <== NOT EXECUTED 10a35d: 6a 04 push $0x4 <== NOT EXECUTED 10a35f: 6a 00 push $0x0 <== NOT EXECUTED 10a361: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 10a364: 50 push %eax <== NOT EXECUTED 10a365: e8 4a 0b 00 00 call 10aeb4 <_CORE_mutex_Flush> <== NOT EXECUTED 10a36a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_SEMAPHORE_WAS_DELETED ); } _Objects_Close( &_Semaphore_Information, &the_semaphore->Object ); 10a36d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a370: 53 push %ebx <== NOT EXECUTED 10a371: 68 40 e9 11 00 push $0x11e940 <== NOT EXECUTED 10a376: e8 75 12 00 00 call 10b5f0 <_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 10a37b: 58 pop %eax <== NOT EXECUTED 10a37c: 5a pop %edx <== NOT EXECUTED 10a37d: 53 push %ebx <== NOT EXECUTED 10a37e: 68 40 e9 11 00 push $0x11e940 <== NOT EXECUTED 10a383: e8 a8 15 00 00 call 10b930 <_Objects_Free> <== NOT EXECUTED 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 10a388: e8 1b 1f 00 00 call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a38d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a38f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a392: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a395: c9 leave <== NOT EXECUTED 10a396: c3 ret <== NOT EXECUTED 10a397: 90 nop <== NOT EXECUTED &the_semaphore->Core_control.mutex, SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_MUTEX_WAS_DELETED ); } else { _CORE_semaphore_Flush( 10a398: 51 push %ecx <== NOT EXECUTED 10a399: 6a 02 push $0x2 <== NOT EXECUTED 10a39b: 6a 00 push $0x0 <== NOT EXECUTED 10a39d: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 10a3a0: 50 push %eax <== NOT EXECUTED 10a3a1: e8 c6 0d 00 00 call 10b16c <_CORE_semaphore_Flush> <== NOT EXECUTED 10a3a6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a3a9: eb c2 jmp 10a36d <== NOT EXECUTED 00125d48 : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 125d48: 55 push %ebp <== NOT EXECUTED 125d49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125d4b: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED * to add to the heap 125d4e: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 125d51: 50 push %eax <== NOT EXECUTED 125d52: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125d55: 68 60 11 16 00 push $0x161160 <== NOT EXECUTED 125d5a: e8 81 b0 fe ff call 110de0 <_Objects_Get> <== NOT EXECUTED register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 125d5f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125d62: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 125d65: 85 d2 test %edx,%edx <== NOT EXECUTED 125d67: 74 07 je 125d70 <== NOT EXECUTED 125d69: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 125d6e: c9 leave <== NOT EXECUTED 125d6f: c3 ret <== NOT EXECUTED the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 125d70: f6 40 10 30 testb $0x30,0x10(%eax) <== NOT EXECUTED 125d74: 75 1a jne 125d90 <== NOT EXECUTED &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 125d76: 52 push %edx <== NOT EXECUTED 125d77: 6a 01 push $0x1 <== NOT EXECUTED 125d79: 6a 00 push $0x0 <== NOT EXECUTED 125d7b: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 125d7e: 50 push %eax <== NOT EXECUTED 125d7f: e8 04 a6 fe ff call 110388 <_CORE_semaphore_Flush> <== NOT EXECUTED 125d84: 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(); 125d87: e8 48 b9 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 125d8c: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 125d8e: c9 leave <== NOT EXECUTED 125d8f: c3 ret <== NOT EXECUTED the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Flush( 125d90: 51 push %ecx <== NOT EXECUTED 125d91: 6a 01 push $0x1 <== NOT EXECUTED 125d93: 6a 00 push $0x0 <== NOT EXECUTED 125d95: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 125d98: 50 push %eax <== NOT EXECUTED 125d99: e8 32 a3 fe ff call 1100d0 <_CORE_mutex_Flush> <== NOT EXECUTED 125d9e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125da1: eb e4 jmp 125d87 <== NOT EXECUTED 00113a80 : rtems_status_code rtems_semaphore_ident( rtems_name name, uint32_t node, rtems_id *id ) { 113a80: 55 push %ebp <== NOT EXECUTED 113a81: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113a83: 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 ); 113a86: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 113a89: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 113a8c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 113a8f: 68 c0 59 13 00 push $0x1359c0 <== NOT EXECUTED 113a94: e8 5b 32 00 00 call 116cf4 <_Objects_Name_to_id_u32> <== NOT EXECUTED 113a99: 8b 04 85 8c a7 12 00 mov 0x12a78c(,%eax,4),%eax <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; } 113aa0: c9 leave <== NOT EXECUTED 113aa1: c3 ret <== NOT EXECUTED 0010a3ac : rtems_status_code rtems_semaphore_obtain( rtems_id id, rtems_option option_set, rtems_interval timeout ) { 10a3ac: 55 push %ebp <== NOT EXECUTED 10a3ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a3af: 56 push %esi <== NOT EXECUTED 10a3b0: 53 push %ebx <== NOT EXECUTED 10a3b1: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10a3b4: 8b 5d 08 mov 0x8(%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 10a3b7: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10a3ba: 50 push %eax <== NOT EXECUTED 10a3bb: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10a3be: 50 push %eax <== NOT EXECUTED 10a3bf: 53 push %ebx <== NOT EXECUTED 10a3c0: 68 40 e9 11 00 push $0x11e940 <== NOT EXECUTED 10a3c5: e8 4e 16 00 00 call 10ba18 <_Objects_Get_isr_disable> <== NOT EXECUTED 10a3ca: 89 c2 mov %eax,%edx <== NOT EXECUTED register Semaphore_Control *the_semaphore; Objects_Locations location; ISR_Level level; the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); switch ( location ) { 10a3cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a3cf: 8b 4d f4 mov -0xc(%ebp),%ecx <== NOT EXECUTED 10a3d2: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a3d4: 74 0e je 10a3e4 <== NOT EXECUTED 10a3d6: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED break; } return RTEMS_INVALID_ID; } 10a3db: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a3de: 5b pop %ebx <== NOT EXECUTED 10a3df: 5e pop %esi <== NOT EXECUTED 10a3e0: c9 leave <== NOT EXECUTED 10a3e1: c3 ret <== NOT EXECUTED 10a3e2: 66 90 xchg %ax,%ax <== NOT EXECUTED the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 10a3e4: f6 40 10 30 testb $0x30,0x10(%eax) <== NOT EXECUTED 10a3e8: 74 3a je 10a424 <== NOT EXECUTED _CORE_mutex_Seize( 10a3ea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a3ed: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10a3f0: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10a3f3: 83 75 0c 01 xorl $0x1,0xc(%ebp) <== NOT EXECUTED 10a3f7: 83 65 0c 01 andl $0x1,0xc(%ebp) <== NOT EXECUTED 10a3fb: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a3fe: 53 push %ebx <== NOT EXECUTED 10a3ff: 8d 40 14 lea 0x14(%eax),%eax <== NOT EXECUTED 10a402: 50 push %eax <== NOT EXECUTED 10a403: e8 b0 0b 00 00 call 10afb8 <_CORE_mutex_Seize> <== NOT EXECUTED id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 10a408: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10a40b: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED 10a410: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10a413: e8 0c 01 00 00 call 10a524 <_Semaphore_Translate_core_mutex_return_code> <== NOT EXECUTED 10a418: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } return RTEMS_INVALID_ID; } 10a41b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a41e: 5b pop %ebx <== NOT EXECUTED 10a41f: 5e pop %esi <== NOT EXECUTED 10a420: c9 leave <== NOT EXECUTED 10a421: c3 ret <== NOT EXECUTED 10a422: 66 90 xchg %ax,%ax <== 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 10a424: 8b 75 f0 mov -0x10(%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( 10a427: 8b 0d bc ea 11 00 mov 0x11eabc,%ecx <== NOT EXECUTED Heap_Control *the_heap, 10a42d: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) <== NOT EXECUTED size_t size 10a434: 8b 40 5c mov 0x5c(%eax),%eax <== NOT EXECUTED 10a437: 85 c0 test %eax,%eax <== NOT EXECUTED 10a439: 75 29 jne 10a464 <== 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. 10a43b: f6 45 0c 01 testb $0x1,0xc(%ebp) <== NOT EXECUTED 10a43f: 74 2b je 10a46c <== NOT EXECUTED * Any other value of @a alignment is taken "as is", i.e., even odd 10a441: 56 push %esi <== NOT EXECUTED 10a442: 9d popf <== NOT EXECUTED * alignments are possible. 10a443: c7 41 34 01 00 00 00 movl $0x1,0x34(%ecx) <== NOT EXECUTED id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 10a44a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a44d: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED 10a452: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10a455: e8 da 00 00 00 call 10a534 <_Semaphore_Translate_core_semaphore_return_code> <== NOT EXECUTED 10a45a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } return RTEMS_INVALID_ID; } 10a45d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a460: 5b pop %ebx <== NOT EXECUTED 10a461: 5e pop %esi <== NOT EXECUTED 10a462: c9 leave <== NOT EXECUTED 10a463: c3 ret <== 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 ); 10a464: 48 dec %eax <== NOT EXECUTED 10a465: 89 42 5c mov %eax,0x5c(%edx) <== NOT EXECUTED 10a468: 56 push %esi <== NOT EXECUTED 10a469: 9d popf <== NOT EXECUTED 10a46a: eb de jmp 10a44a <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a46c: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10a471: 40 inc %eax <== NOT EXECUTED 10a472: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== 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 10a477: c7 42 44 01 00 00 00 movl $0x1,0x44(%edx) <== 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 10a47e: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 10a481: 89 41 44 mov %eax,0x44(%ecx) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10a484: 89 59 20 mov %ebx,0x20(%ecx) <== NOT EXECUTED */ 10a487: 56 push %esi <== NOT EXECUTED 10a488: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, 10a489: 52 push %edx <== NOT EXECUTED 10a48a: 68 b8 ca 10 00 push $0x10cab8 <== NOT EXECUTED 10a48f: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10a492: 50 push %eax <== NOT EXECUTED 10a493: e8 d0 22 00 00 call 10c768 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED size_t size, 10a498: e8 0b 1e 00 00 call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a49d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a4a0: eb a8 jmp 10a44a <== NOT EXECUTED 0010a4a4 : #endif rtems_status_code rtems_semaphore_release( rtems_id id ) { 10a4a4: 55 push %ebp <== NOT EXECUTED 10a4a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4a7: 53 push %ebx <== NOT EXECUTED 10a4a8: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10a4ab: 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 10a4ae: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a4b1: 50 push %eax <== NOT EXECUTED 10a4b2: 53 push %ebx <== NOT EXECUTED 10a4b3: 68 40 e9 11 00 push $0x11e940 <== NOT EXECUTED 10a4b8: e8 a7 15 00 00 call 10ba64 <_Objects_Get> <== NOT EXECUTED Objects_Locations location; CORE_mutex_Status mutex_status; CORE_semaphore_Status semaphore_status; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 10a4bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a4c0: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10a4c3: 85 d2 test %edx,%edx <== NOT EXECUTED 10a4c5: 74 0d je 10a4d4 <== NOT EXECUTED 10a4c7: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a4cc: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a4cf: c9 leave <== NOT EXECUTED 10a4d0: c3 ret <== NOT EXECUTED 10a4d1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 10a4d4: f6 40 10 30 testb $0x30,0x10(%eax) <== NOT EXECUTED 10a4d8: 75 26 jne 10a500 <== NOT EXECUTED MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return _Semaphore_Translate_core_mutex_return_code( mutex_status ); } else { semaphore_status = _CORE_semaphore_Surrender( 10a4da: 52 push %edx <== NOT EXECUTED 10a4db: 6a 00 push $0x0 <== NOT EXECUTED 10a4dd: 53 push %ebx <== NOT EXECUTED 10a4de: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 10a4e1: 50 push %eax <== NOT EXECUTED 10a4e2: e8 d1 0c 00 00 call 10b1b8 <_CORE_semaphore_Surrender> <== NOT EXECUTED 10a4e7: 89 c3 mov %eax,%ebx <== NOT EXECUTED &the_semaphore->Core_control.semaphore, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 10a4e9: e8 ba 1d 00 00 call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED return 10a4ee: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a4f1: e8 3e 00 00 00 call 10a534 <_Semaphore_Translate_core_semaphore_return_code> <== NOT EXECUTED 10a4f6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a4f9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a4fc: c9 leave <== NOT EXECUTED 10a4fd: c3 ret <== NOT EXECUTED 10a4fe: 66 90 xchg %ax,%ax <== NOT EXECUTED the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { mutex_status = _CORE_mutex_Surrender( 10a500: 51 push %ecx <== NOT EXECUTED 10a501: 6a 00 push $0x0 <== NOT EXECUTED 10a503: 53 push %ebx <== NOT EXECUTED 10a504: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 10a507: 50 push %eax <== NOT EXECUTED 10a508: e8 47 0b 00 00 call 10b054 <_CORE_mutex_Surrender> <== NOT EXECUTED 10a50d: 89 c3 mov %eax,%ebx <== NOT EXECUTED &the_semaphore->Core_control.mutex, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 10a50f: e8 94 1d 00 00 call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED return _Semaphore_Translate_core_mutex_return_code( mutex_status ); 10a514: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a517: e8 08 00 00 00 call 10a524 <_Semaphore_Translate_core_mutex_return_code> <== NOT EXECUTED 10a51c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a51f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a522: c9 leave <== NOT EXECUTED 10a523: c3 ret <== NOT EXECUTED 00116818 : */ void rtems_shutdown_executive( uint32_t result ) { 116818: 55 push %ebp <== NOT EXECUTED 116819: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11681b: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 11681e: 83 3d c4 eb 11 00 04 cmpl $0x4,0x11ebc4 <== NOT EXECUTED 116825: 74 1e je 116845 <== 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( 116827: c7 05 c4 eb 11 00 04 movl $0x4,0x11ebc4 <== NOT EXECUTED 11682e: 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 116831: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 116834: 68 e0 e9 11 00 push $0x11e9e0 <== NOT EXECUTED 116839: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 11683c: 50 push %eax <== NOT EXECUTED 11683d: e8 3e 6c ff ff call 10d480 <_CPU_Context_switch> <== NOT EXECUTED 116842: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_SHUTDOWN ); _Thread_Stop_multitasking(); } } 116845: c9 leave <== NOT EXECUTED 116846: c3 ret <== NOT EXECUTED 0010b1e0 : rtems_status_code rtems_signal_catch( rtems_asr_entry asr_handler, rtems_mode mode_set ) { 10b1e0: 55 push %ebp <== NOT EXECUTED 10b1e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b1e3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b1e6: 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 ]; 10b1e9: a1 9c 17 12 00 mov 0x12179c,%eax <== NOT EXECUTED 10b1ee: 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 10b1f4: a1 d8 16 12 00 mov 0x1216d8,%eax <== NOT EXECUTED 10b1f9: 40 inc %eax <== NOT EXECUTED 10b1fa: a3 d8 16 12 00 mov %eax,0x1216d8 <== NOT EXECUTED asr = &api->Signal; _Thread_Disable_dispatch(); /* cannot reschedule while */ /* the thread is inconsistent */ if ( !_ASR_Is_null_handler( asr_handler ) ) { 10b1ff: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b201: 74 15 je 10b218 <== NOT EXECUTED asr->mode_set = mode_set; 10b203: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b206: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED asr->handler = asr_handler; 10b209: 89 4a 0c mov %ecx,0xc(%edx) <== NOT EXECUTED } else _ASR_Initialize( asr ); _Thread_Enable_dispatch(); 10b20c: e8 0b 21 00 00 call 10d31c <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10b211: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b213: c9 leave <== NOT EXECUTED 10b214: c3 ret <== NOT EXECUTED 10b215: 8d 76 00 lea 0x0(%esi),%esi <== 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 10b218: 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 10b21c: 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. 10b223: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED * 10b22a: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10b231: 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 10b238: c7 42 1c 00 00 00 00 movl $0x0,0x1c(%edx) <== NOT EXECUTED asr->mode_set = mode_set; asr->handler = asr_handler; } else _ASR_Initialize( asr ); _Thread_Enable_dispatch(); 10b23f: e8 d8 20 00 00 call 10d31c <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10b244: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b246: c9 leave <== NOT EXECUTED 10b247: c3 ret <== NOT EXECUTED 00113c3c : rtems_status_code rtems_signal_send( Objects_Id id, rtems_signal_set signal_set ) { 113c3c: 55 push %ebp <== NOT EXECUTED 113c3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113c3f: 53 push %ebx <== NOT EXECUTED 113c40: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 113c43: 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 ) 113c46: 85 db test %ebx,%ebx <== NOT EXECUTED 113c48: 75 0a jne 113c54 <== NOT EXECUTED 113c4a: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 113c4f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 113c52: c9 leave <== NOT EXECUTED 113c53: c3 ret <== NOT EXECUTED ASR_Information *asr; if ( !signal_set ) return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 113c54: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 113c57: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 113c5a: 50 push %eax <== NOT EXECUTED 113c5b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 113c5e: e8 a1 37 00 00 call 117404 <_Thread_Get> <== NOT EXECUTED 113c63: 89 c1 mov %eax,%ecx <== NOT EXECUTED switch ( location ) { 113c65: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113c68: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 113c6b: 85 d2 test %edx,%edx <== NOT EXECUTED 113c6d: 74 0d je 113c7c <== NOT EXECUTED 113c6f: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 113c74: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 113c77: c9 leave <== NOT EXECUTED 113c78: c3 ret <== NOT EXECUTED 113c79: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 113c7c: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx <== NOT EXECUTED asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 113c82: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 113c85: 85 c0 test %eax,%eax <== NOT EXECUTED 113c87: 74 43 je 113ccc <== NOT EXECUTED if ( asr->is_enabled ) { 113c89: 80 7a 08 00 cmpb $0x0,0x8(%edx) <== NOT EXECUTED 113c8d: 74 29 je 113cb8 <== 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 113c8f: 9c pushf <== NOT EXECUTED 113c90: fa cli <== NOT EXECUTED 113c91: 58 pop %eax <== NOT EXECUTED ); 113c92: 09 5a 14 or %ebx,0x14(%edx) <== NOT EXECUTED 113c95: 50 push %eax <== NOT EXECUTED 113c96: 9d popf <== NOT EXECUTED _ASR_Post_signals( signal_set, &asr->signals_posted ); the_thread->do_post_task_switch_extension = true; 113c97: c6 41 75 01 movb $0x1,0x75(%ecx) <== NOT EXECUTED if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 113c9b: a1 98 5b 13 00 mov 0x135b98,%eax <== NOT EXECUTED 113ca0: 85 c0 test %eax,%eax <== NOT EXECUTED 113ca2: 74 1c je 113cc0 <== NOT EXECUTED 113ca4: 3b 0d bc 5b 13 00 cmp 0x135bbc,%ecx <== NOT EXECUTED 113caa: 75 14 jne 113cc0 <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 113cac: c6 05 68 5c 13 00 01 movb $0x1,0x135c68 <== NOT EXECUTED 113cb3: eb 0b jmp 113cc0 <== NOT EXECUTED 113cb5: 8d 76 00 lea 0x0(%esi),%esi <== 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 113cb8: 9c pushf <== NOT EXECUTED 113cb9: fa cli <== NOT EXECUTED 113cba: 58 pop %eax <== NOT EXECUTED ); 113cbb: 09 5a 18 or %ebx,0x18(%edx) <== NOT EXECUTED 113cbe: 50 push %eax <== NOT EXECUTED 113cbf: 9d popf <== NOT EXECUTED } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 113cc0: e8 1b 37 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 113cc5: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 113cc7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 113cca: c9 leave <== NOT EXECUTED 113ccb: c3 ret <== NOT EXECUTED _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 113ccc: e8 0f 37 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 113cd1: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 113cd6: e9 74 ff ff ff jmp 113c4f <== NOT EXECUTED 0010a544 : size_t stack_size, rtems_mode initial_modes, rtems_attribute attribute_set, Objects_Id *id ) { 10a544: 55 push %ebp <== NOT EXECUTED 10a545: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a547: 57 push %edi <== NOT EXECUTED 10a548: 56 push %esi <== NOT EXECUTED 10a549: 53 push %ebx <== NOT EXECUTED 10a54a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a54d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10a550: 8b 5d 18 mov 0x18(%ebp),%ebx <== NOT EXECUTED Priority_Control core_priority; RTEMS_API_Control *api; ASR_Information *asr; if ( !id ) 10a553: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 10a556: 85 c0 test %eax,%eax <== NOT EXECUTED 10a558: 0f 84 32 01 00 00 je 10a690 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10a55e: 85 ff test %edi,%edi <== NOT EXECUTED 10a560: 0f 84 c2 00 00 00 je 10a628 <== NOT EXECUTED /* * Validate the RTEMS API priority and convert it to the core priority range. */ if ( !_Attributes_Is_system_task( the_attribute_set ) ) { 10a566: 66 85 db test %bx,%bx <== NOT EXECUTED 10a569: 78 1b js 10a586 <== NOT EXECUTED bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ); 10a56b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a56e: 85 c0 test %eax,%eax <== NOT EXECUTED 10a570: 0f 84 f2 00 00 00 je 10a668 <== NOT EXECUTED 10a576: 0f b6 05 b4 a4 11 00 movzbl 0x11a4b4,%eax <== NOT EXECUTED 10a57d: 39 45 0c cmp %eax,0xc(%ebp) <== NOT EXECUTED 10a580: 0f 87 e2 00 00 00 ja 10a668 <== NOT EXECUTED */ /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 10a586: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a589: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10a58f: e8 30 07 00 00 call 10acc4 <_API_Mutex_Lock> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 10a594: c7 04 24 80 e9 11 00 movl $0x11e980,(%esp) <== NOT EXECUTED 10a59b: e8 d0 0f 00 00 call 10b570 <_Objects_Allocate> <== NOT EXECUTED 10a5a0: 89 c6 mov %eax,%esi <== NOT EXECUTED * the event of an error. */ the_thread = _RTEMS_tasks_Allocate(); if ( !the_thread ) { 10a5a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a5a5: 85 c0 test %eax,%eax <== NOT EXECUTED 10a5a7: 0f 84 cb 00 00 00 je 10a678 <== NOT EXECUTED /* * Initialize the core thread for this task. */ status = _Thread_Initialize( 10a5ad: 50 push %eax <== NOT EXECUTED 10a5ae: 57 push %edi <== NOT EXECUTED 10a5af: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a5b2: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10a5b5: 50 push %eax <== NOT EXECUTED 10a5b6: 6a 00 push $0x0 <== NOT EXECUTED 10a5b8: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a5bb: c1 e8 09 shr $0x9,%eax <== NOT EXECUTED 10a5be: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10a5c1: 50 push %eax <== NOT EXECUTED 10a5c2: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a5c5: c1 e8 08 shr $0x8,%eax <== NOT EXECUTED 10a5c8: 83 f0 01 xor $0x1,%eax <== NOT EXECUTED 10a5cb: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10a5ce: 50 push %eax <== NOT EXECUTED 10a5cf: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a5d2: 83 e3 01 and $0x1,%ebx <== NOT EXECUTED 10a5d5: 53 push %ebx <== NOT EXECUTED 10a5d6: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10a5d9: 6a 00 push $0x0 <== NOT EXECUTED 10a5db: 56 push %esi <== NOT EXECUTED 10a5dc: 68 80 e9 11 00 push $0x11e980 <== NOT EXECUTED 10a5e1: e8 66 1d 00 00 call 10c34c <_Thread_Initialize> <== NOT EXECUTED NULL, /* no budget algorithm callout */ _Modes_Get_interrupt_level(initial_modes), (Objects_Name) name ); if ( !status ) { 10a5e6: 83 c4 30 add $0x30,%esp <== NOT EXECUTED 10a5e9: 84 c0 test %al,%al <== NOT EXECUTED 10a5eb: 74 4b je 10a638 <== NOT EXECUTED } api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true; 10a5ed: 8b 86 f4 00 00 00 mov 0xf4(%esi),%eax <== NOT EXECUTED 10a5f3: c1 6d 14 0a shrl $0xa,0x14(%ebp) <== NOT EXECUTED 10a5f7: 83 75 14 01 xorl $0x1,0x14(%ebp) <== NOT EXECUTED 10a5fb: 8a 55 14 mov 0x14(%ebp),%dl <== NOT EXECUTED 10a5fe: 83 e2 01 and $0x1,%edx <== NOT EXECUTED 10a601: 88 50 08 mov %dl,0x8(%eax) <== NOT EXECUTED *id = the_thread->Object.id; 10a604: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10a607: 8b 55 1c mov 0x1c(%ebp),%edx <== NOT EXECUTED 10a60a: 89 02 mov %eax,(%edx) <== NOT EXECUTED ); } #endif _RTEMS_Unlock_allocator(); 10a60c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a60f: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10a615: e8 f2 06 00 00 call 10ad0c <_API_Mutex_Unlock> <== NOT EXECUTED 10a61a: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a61c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10a61f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a622: 5b pop %ebx <== NOT EXECUTED 10a623: 5e pop %esi <== NOT EXECUTED 10a624: 5f pop %edi <== NOT EXECUTED 10a625: c9 leave <== NOT EXECUTED 10a626: c3 ret <== NOT EXECUTED 10a627: 90 nop <== NOT EXECUTED if ( !id ) return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10a628: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } 10a62d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a630: 5b pop %ebx <== NOT EXECUTED 10a631: 5e pop %esi <== NOT EXECUTED 10a632: 5f pop %edi <== NOT EXECUTED 10a633: c9 leave <== NOT EXECUTED 10a634: c3 ret <== NOT EXECUTED 10a635: 8d 76 00 lea 0x0(%esi),%esi <== 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 10a638: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a63b: ff 76 08 pushl 0x8(%esi) <== NOT EXECUTED 10a63e: e8 61 13 00 00 call 10b9a4 <_Objects_Get_information_id> <== NOT EXECUTED 10a643: 5a pop %edx <== NOT EXECUTED 10a644: 59 pop %ecx <== NOT EXECUTED 10a645: 56 push %esi <== NOT EXECUTED 10a646: 50 push %eax <== NOT EXECUTED 10a647: e8 e4 12 00 00 call 10b930 <_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(); 10a64c: 58 pop %eax <== NOT EXECUTED 10a64d: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10a653: e8 b4 06 00 00 call 10ad0c <_API_Mutex_Unlock> <== NOT EXECUTED 10a658: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 10a65d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } 10a660: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a663: 5b pop %ebx <== NOT EXECUTED 10a664: 5e pop %esi <== NOT EXECUTED 10a665: 5f pop %edi <== NOT EXECUTED 10a666: c9 leave <== NOT EXECUTED 10a667: c3 ret <== NOT EXECUTED } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; 10a668: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED } 10a66d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a670: 5b pop %ebx <== NOT EXECUTED 10a671: 5e pop %esi <== NOT EXECUTED 10a672: 5f pop %edi <== NOT EXECUTED 10a673: c9 leave <== NOT EXECUTED 10a674: c3 ret <== NOT EXECUTED 10a675: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ the_thread = _RTEMS_tasks_Allocate(); if ( !the_thread ) { _RTEMS_Unlock_allocator(); 10a678: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a67b: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10a681: e8 86 06 00 00 call 10ad0c <_API_Mutex_Unlock> <== NOT EXECUTED 10a686: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10a68b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a68e: eb 9d jmp 10a62d <== NOT EXECUTED Priority_Control core_priority; RTEMS_API_Control *api; ASR_Information *asr; if ( !id ) 10a690: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a695: eb 96 jmp 10a62d <== NOT EXECUTED 0010a698 : */ rtems_status_code rtems_task_delete( Objects_Id id ) { 10a698: 55 push %ebp <== NOT EXECUTED 10a699: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a69b: 53 push %ebx <== NOT EXECUTED 10a69c: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; _RTEMS_Lock_allocator(); 10a69f: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10a6a5: e8 1a 06 00 00 call 10acc4 <_API_Mutex_Lock> <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); 10a6aa: 58 pop %eax <== NOT EXECUTED 10a6ab: 5a pop %edx <== NOT EXECUTED 10a6ac: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a6af: 50 push %eax <== NOT EXECUTED 10a6b0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a6b3: e8 14 1c 00 00 call 10c2cc <_Thread_Get> <== NOT EXECUTED 10a6b8: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch ( location ) { 10a6ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a6bd: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10a6c0: 85 c0 test %eax,%eax <== NOT EXECUTED 10a6c2: 75 44 jne 10a708 <== NOT EXECUTED case OBJECTS_LOCAL: the_information = _Objects_Get_information_id( the_thread->Object.id ); 10a6c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a6c7: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10a6ca: e8 d5 12 00 00 call 10b9a4 <_Objects_Get_information_id> <== NOT EXECUTED 0 /* Not used */ ); } #endif _Thread_Close( the_information, the_thread ); 10a6cf: 5a pop %edx <== NOT EXECUTED 10a6d0: 59 pop %ecx <== NOT EXECUTED 10a6d1: 53 push %ebx <== NOT EXECUTED 10a6d2: 50 push %eax <== NOT EXECUTED 10a6d3: e8 b4 18 00 00 call 10bf8c <_Thread_Close> <== NOT EXECUTED 10a6d8: 58 pop %eax <== NOT EXECUTED 10a6d9: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10a6dc: e8 c3 12 00 00 call 10b9a4 <_Objects_Get_information_id> <== NOT EXECUTED 10a6e1: 5a pop %edx <== NOT EXECUTED 10a6e2: 59 pop %ecx <== NOT EXECUTED 10a6e3: 53 push %ebx <== NOT EXECUTED 10a6e4: 50 push %eax <== NOT EXECUTED 10a6e5: e8 46 12 00 00 call 10b930 <_Objects_Free> <== NOT EXECUTED _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 10a6ea: 58 pop %eax <== NOT EXECUTED 10a6eb: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10a6f1: e8 16 06 00 00 call 10ad0c <_API_Mutex_Unlock> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a6f6: e8 ad 1b 00 00 call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a6fb: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a6fd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; } 10a700: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a703: c9 leave <== NOT EXECUTED 10a704: c3 ret <== NOT EXECUTED 10a705: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED case OBJECTS_ERROR: break; } _RTEMS_Unlock_allocator(); 10a708: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a70b: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10a711: e8 f6 05 00 00 call 10ad0c <_API_Mutex_Unlock> <== NOT EXECUTED 10a716: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10a71b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_INVALID_ID; } 10a71e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a721: c9 leave <== NOT EXECUTED 10a722: c3 ret <== NOT EXECUTED 0010bdf0 : rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) { 10bdf0: 55 push %ebp <== NOT EXECUTED 10bdf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bdf3: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10bdf6: a1 b4 29 12 00 mov 0x1229b4,%eax <== NOT EXECUTED 10bdfb: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10bdfe: 80 78 04 00 cmpb $0x0,0x4(%eax) <== NOT EXECUTED 10be02: 74 64 je 10be68 <== NOT EXECUTED return RTEMS_NOT_CONFIGURED; if ( !note ) 10be04: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10be07: 85 c0 test %eax,%eax <== NOT EXECUTED 10be09: 0f 84 85 00 00 00 je 10be94 <== 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 ) 10be0f: 83 7d 0c 0f cmpl $0xf,0xc(%ebp) <== NOT EXECUTED 10be13: 77 4b ja 10be60 <== NOT EXECUTED /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10be15: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10be18: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10be1a: 74 54 je 10be70 <== NOT EXECUTED 10be1c: a1 dc 29 12 00 mov 0x1229dc,%eax <== NOT EXECUTED 10be21: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10be24: 3b 50 08 cmp 0x8(%eax),%edx <== NOT EXECUTED 10be27: 74 4c je 10be75 <== NOT EXECUTED api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10be29: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10be2c: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10be2f: 50 push %eax <== NOT EXECUTED 10be30: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10be33: e8 e8 1e 00 00 call 10dd20 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10be38: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10be3b: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10be3e: 85 d2 test %edx,%edx <== NOT EXECUTED 10be40: 75 4a jne 10be8c <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10be42: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10be48: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10be4b: 8b 44 90 20 mov 0x20(%eax,%edx,4),%eax <== NOT EXECUTED 10be4f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10be52: 89 02 mov %eax,(%edx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10be54: e8 a3 1e 00 00 call 10dcfc <_Thread_Enable_dispatch> <== NOT EXECUTED 10be59: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10be5b: c9 leave <== NOT EXECUTED 10be5c: c3 ret <== NOT EXECUTED 10be5d: 8d 76 00 lea 0x0(%esi),%esi <== 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 ) 10be60: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10be65: c9 leave <== NOT EXECUTED 10be66: c3 ret <== NOT EXECUTED 10be67: 90 nop <== NOT EXECUTED { register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10be68: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10be6d: c9 leave <== NOT EXECUTED 10be6e: c3 ret <== NOT EXECUTED 10be6f: 90 nop <== NOT EXECUTED 10be70: a1 dc 29 12 00 mov 0x1229dc,%eax <== NOT EXECUTED */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10be75: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10be7b: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10be7e: 8b 44 90 20 mov 0x20(%eax,%edx,4),%eax <== NOT EXECUTED 10be82: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10be85: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10be87: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10be89: c9 leave <== NOT EXECUTED 10be8a: c3 ret <== NOT EXECUTED 10be8b: 90 nop <== NOT EXECUTED *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 10be8c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10be91: c9 leave <== NOT EXECUTED 10be92: c3 ret <== NOT EXECUTED 10be93: 90 nop <== NOT EXECUTED RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) return RTEMS_NOT_CONFIGURED; if ( !note ) 10be94: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10be99: c9 leave <== NOT EXECUTED 10be9a: c3 ret <== NOT EXECUTED 0010a724 : rtems_status_code rtems_task_ident( rtems_name name, uint32_t node, Objects_Id *id ) { 10a724: 55 push %ebp <== NOT EXECUTED 10a725: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a727: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a72a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a72d: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; if ( !id ) 10a730: 85 d2 test %edx,%edx <== NOT EXECUTED 10a732: 74 30 je 10a764 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( name == OBJECTS_ID_OF_SELF ) { 10a734: 85 c0 test %eax,%eax <== NOT EXECUTED 10a736: 75 10 jne 10a748 <== NOT EXECUTED *id = _Thread_Executing->Object.id; 10a738: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED 10a73d: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10a740: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10a742: 31 c0 xor %eax,%eax <== NOT EXECUTED } status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id ); return _Status_Object_name_errors_to_status[ status ]; } 10a744: c9 leave <== NOT EXECUTED 10a745: c3 ret <== NOT EXECUTED 10a746: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( name == OBJECTS_ID_OF_SELF ) { *id = _Thread_Executing->Object.id; return RTEMS_SUCCESSFUL; } status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id ); 10a748: 52 push %edx <== NOT EXECUTED 10a749: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a74c: 50 push %eax <== NOT EXECUTED 10a74d: 68 80 e9 11 00 push $0x11e980 <== NOT EXECUTED 10a752: e8 65 14 00 00 call 10bbbc <_Objects_Name_to_id_u32> <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; 10a757: 8b 04 85 ac 85 11 00 mov 0x1185ac(,%eax,4),%eax <== NOT EXECUTED 10a75e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10a761: c9 leave <== NOT EXECUTED 10a762: c3 ret <== NOT EXECUTED 10a763: 90 nop <== NOT EXECUTED Objects_Id *id ) { Objects_Name_or_id_lookup_errors status; if ( !id ) 10a764: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED } status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id ); return _Status_Object_name_errors_to_status[ status ]; } 10a769: c9 leave <== NOT EXECUTED 10a76a: c3 ret <== NOT EXECUTED 0010acd8 : */ rtems_status_code rtems_task_is_suspended( Objects_Id id ) { 10acd8: 55 push %ebp <== NOT EXECUTED 10acd9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10acdb: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10acde: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10ace1: 50 push %eax <== NOT EXECUTED 10ace2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ace5: e8 ea 1b 00 00 call 10c8d4 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10acea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aced: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10acf0: 85 d2 test %edx,%edx <== NOT EXECUTED 10acf2: 74 08 je 10acfc <== NOT EXECUTED 10acf4: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10acf9: c9 leave <== NOT EXECUTED 10acfa: c3 ret <== NOT EXECUTED 10acfb: 90 nop <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 10acfc: f6 40 10 02 testb $0x2,0x10(%eax) <== NOT EXECUTED 10ad00: 74 0e je 10ad10 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10ad02: e8 a9 1b 00 00 call 10c8b0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ad07: b8 0f 00 00 00 mov $0xf,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ad0c: c9 leave <== NOT EXECUTED 10ad0d: c3 ret <== NOT EXECUTED 10ad0e: 66 90 xchg %ax,%ax <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { _Thread_Enable_dispatch(); 10ad10: e8 9b 1b 00 00 call 10c8b0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ad15: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ad17: c9 leave <== NOT EXECUTED 10ad18: c3 ret <== NOT EXECUTED 0010fce8 : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 10fce8: 55 push %ebp <== NOT EXECUTED 10fce9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fceb: 57 push %edi <== NOT EXECUTED 10fcec: 56 push %esi <== NOT EXECUTED 10fced: 53 push %ebx <== NOT EXECUTED 10fcee: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fcf1: 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 ) 10fcf4: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10fcf7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10fcf9: 0f 84 31 01 00 00 je 10fe30 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 10fcff: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED 10fd04: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10fd07: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx <== NOT EXECUTED 10fd0d: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 10fd10: 80 78 76 01 cmpb $0x1,0x76(%eax) <== NOT EXECUTED 10fd14: 19 f6 sbb %esi,%esi <== NOT EXECUTED 10fd16: 81 e6 00 01 00 00 and $0x100,%esi <== NOT EXECUTED if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 10fd1c: 8b 50 7c mov 0x7c(%eax),%edx <== NOT EXECUTED 10fd1f: 85 d2 test %edx,%edx <== NOT EXECUTED 10fd21: 0f 85 bd 00 00 00 jne 10fde4 <== NOT EXECUTED old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 10fd27: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 10fd2a: 80 7b 08 01 cmpb $0x1,0x8(%ebx) <== NOT EXECUTED 10fd2e: 19 db sbb %ebx,%ebx <== NOT EXECUTED 10fd30: 81 e3 00 04 00 00 and $0x400,%ebx <== NOT EXECUTED old_mode |= _ISR_Get_level(); 10fd36: e8 21 d9 ff ff call 10d65c <_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; 10fd3b: 09 c3 or %eax,%ebx <== NOT EXECUTED old_mode |= _ISR_Get_level(); *previous_mode_set = old_mode; 10fd3d: 09 f3 or %esi,%ebx <== NOT EXECUTED 10fd3f: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10fd42: 89 18 mov %ebx,(%eax) <== NOT EXECUTED /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 10fd44: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) <== NOT EXECUTED 10fd4b: 74 11 je 10fd5e <== NOT EXECUTED executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE; 10fd4d: 89 f8 mov %edi,%eax <== NOT EXECUTED 10fd4f: c1 e8 08 shr $0x8,%eax <== NOT EXECUTED 10fd52: 83 f0 01 xor $0x1,%eax <== NOT EXECUTED 10fd55: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10fd58: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10fd5b: 88 42 76 mov %al,0x76(%edx) <== NOT EXECUTED if ( mask & RTEMS_TIMESLICE_MASK ) { 10fd5e: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) <== NOT EXECUTED 10fd65: 74 1e je 10fd85 <== NOT EXECUTED if ( _Modes_Is_timeslice(mode_set) ) { 10fd67: f7 c7 00 02 00 00 test $0x200,%edi <== NOT EXECUTED 10fd6d: 0f 84 81 00 00 00 je 10fdf4 <== NOT EXECUTED executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 10fd73: 8b 5d ec mov -0x14(%ebp),%ebx <== NOT EXECUTED 10fd76: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx) <== NOT EXECUTED executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10fd7d: a1 c4 e9 11 00 mov 0x11e9c4,%eax <== NOT EXECUTED 10fd82: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 10fd85: f6 45 0c 01 testb $0x1,0xc(%ebp) <== NOT EXECUTED 10fd89: 74 09 je 10fd94 <== 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 10fd8b: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED 10fd91: 74 5d je 10fdf0 <== NOT EXECUTED 10fd93: fa cli <== NOT EXECUTED */ is_asr_enabled = FALSE; needs_asr_dispatching = FALSE; if ( mask & RTEMS_ASR_MASK ) { 10fd94: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) <== NOT EXECUTED 10fd9b: 74 31 je 10fdce <== NOT EXECUTED 10fd9d: c1 ef 0a shr $0xa,%edi <== NOT EXECUTED 10fda0: 83 f7 01 xor $0x1,%edi <== NOT EXECUTED 10fda3: 89 f8 mov %edi,%eax <== NOT EXECUTED 10fda5: 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 ) { 10fda8: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10fdab: 38 42 08 cmp %al,0x8(%edx) <== NOT EXECUTED 10fdae: 74 1e je 10fdce <== NOT EXECUTED asr->is_enabled = is_asr_enabled; 10fdb0: 88 42 08 mov %al,0x8(%edx) <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10fdb3: 9c pushf <== NOT EXECUTED 10fdb4: fa cli <== NOT EXECUTED 10fdb5: 59 pop %ecx <== NOT EXECUTED /** 10fdb6: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 10fdb9: 8b 53 18 mov 0x18(%ebx),%edx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 10fdbc: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10fdbf: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED * begin at @a starting_address. 10fdc2: 89 53 14 mov %edx,0x14(%ebx) <== NOT EXECUTED * 10fdc5: 51 push %ecx <== NOT EXECUTED 10fdc6: 9d popf <== NOT EXECUTED _ASR_Swap_signals( asr ); if ( _ASR_Are_signals_pending( asr ) ) { 10fdc7: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10fdca: 85 c0 test %eax,%eax <== NOT EXECUTED 10fdcc: 75 56 jne 10fe24 <== NOT EXECUTED needs_asr_dispatching = true; executing->do_post_task_switch_extension = true; 10fdce: 31 db xor %ebx,%ebx <== NOT EXECUTED } } } if ( _System_state_Is_up(_System_state_Current) ) 10fdd0: 83 3d c4 eb 11 00 03 cmpl $0x3,0x11ebc4 <== NOT EXECUTED 10fdd7: 74 2f je 10fe08 <== NOT EXECUTED if ( _Thread_Evaluate_mode() || needs_asr_dispatching ) _Thread_Dispatch(); 10fdd9: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10fddb: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10fdde: 5b pop %ebx <== NOT EXECUTED 10fddf: 5e pop %esi <== NOT EXECUTED 10fde0: 5f pop %edi <== NOT EXECUTED 10fde1: c9 leave <== NOT EXECUTED 10fde2: c3 ret <== NOT EXECUTED 10fde3: 90 nop <== NOT EXECUTED old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 10fde4: 81 ce 00 02 00 00 or $0x200,%esi <== NOT EXECUTED 10fdea: e9 38 ff ff ff jmp 10fd27 <== NOT EXECUTED 10fdef: 90 nop <== 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 10fdf0: fb sti <== NOT EXECUTED 10fdf1: eb a1 jmp 10fd94 <== NOT EXECUTED 10fdf3: 90 nop <== NOT EXECUTED if ( mask & RTEMS_TIMESLICE_MASK ) { if ( _Modes_Is_timeslice(mode_set) ) { executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; executing->cpu_time_budget = _Thread_Ticks_per_timeslice; } else executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 10fdf4: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10fdf7: c7 40 7c 00 00 00 00 movl $0x0,0x7c(%eax) <== NOT EXECUTED /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 10fdfe: f6 45 0c 01 testb $0x1,0xc(%ebp) <== NOT EXECUTED 10fe02: 74 90 je 10fd94 <== NOT EXECUTED 10fe04: eb 85 jmp 10fd8b <== NOT EXECUTED 10fe06: 66 90 xchg %ax,%ax <== NOT EXECUTED } } } if ( _System_state_Is_up(_System_state_Current) ) if ( _Thread_Evaluate_mode() || needs_asr_dispatching ) 10fe08: e8 73 01 00 00 call 10ff80 <_Thread_Evaluate_mode> <== NOT EXECUTED 10fe0d: 84 c0 test %al,%al <== NOT EXECUTED 10fe0f: 75 04 jne 10fe15 <== NOT EXECUTED 10fe11: 84 db test %bl,%bl <== NOT EXECUTED 10fe13: 74 c4 je 10fdd9 <== NOT EXECUTED _Thread_Dispatch(); 10fe15: e8 32 c3 ff ff call 10c14c <_Thread_Dispatch> <== NOT EXECUTED 10fe1a: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10fe1c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10fe1f: 5b pop %ebx <== NOT EXECUTED 10fe20: 5e pop %esi <== NOT EXECUTED 10fe21: 5f pop %edi <== NOT EXECUTED 10fe22: c9 leave <== NOT EXECUTED 10fe23: c3 ret <== NOT EXECUTED if ( is_asr_enabled != asr->is_enabled ) { asr->is_enabled = is_asr_enabled; _ASR_Swap_signals( asr ); if ( _ASR_Are_signals_pending( asr ) ) { needs_asr_dispatching = true; executing->do_post_task_switch_extension = true; 10fe24: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10fe27: c6 40 75 01 movb $0x1,0x75(%eax) <== NOT EXECUTED 10fe2b: b3 01 mov $0x1,%bl <== NOT EXECUTED 10fe2d: eb a1 jmp 10fdd0 <== NOT EXECUTED 10fe2f: 90 nop <== NOT EXECUTED ASR_Information *asr; bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) 10fe30: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED if ( _System_state_Is_up(_System_state_Current) ) if ( _Thread_Evaluate_mode() || needs_asr_dispatching ) _Thread_Dispatch(); return RTEMS_SUCCESSFUL; } 10fe35: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10fe38: 5b pop %ebx <== NOT EXECUTED 10fe39: 5e pop %esi <== NOT EXECUTED 10fe3a: 5f pop %edi <== NOT EXECUTED 10fe3b: c9 leave <== NOT EXECUTED 10fe3c: c3 ret <== NOT EXECUTED 0010b108 : rtems_status_code rtems_task_restart( Objects_Id id, uint32_t argument ) { 10b108: 55 push %ebp <== NOT EXECUTED 10b109: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b10b: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10b10e: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b111: 50 push %eax <== NOT EXECUTED 10b112: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b115: e8 ea 1b 00 00 call 10cd04 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10b11a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b11d: 8b 4d fc mov -0x4(%ebp),%ecx <== NOT EXECUTED 10b120: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b122: 75 20 jne 10b144 <== NOT EXECUTED case OBJECTS_LOCAL: if ( _Thread_Restart( the_thread, NULL, argument ) ) { 10b124: 52 push %edx <== NOT EXECUTED 10b125: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b128: 6a 00 push $0x0 <== NOT EXECUTED 10b12a: 50 push %eax <== NOT EXECUTED 10b12b: e8 f8 23 00 00 call 10d528 <_Thread_Restart> <== NOT EXECUTED 10b130: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b133: 84 c0 test %al,%al <== NOT EXECUTED 10b135: 75 15 jne 10b14c <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10b137: e8 a4 1b 00 00 call 10cce0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b13c: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b141: c9 leave <== NOT EXECUTED 10b142: c3 ret <== NOT EXECUTED 10b143: 90 nop <== NOT EXECUTED { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 10b144: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b149: c9 leave <== NOT EXECUTED 10b14a: c3 ret <== NOT EXECUTED 10b14b: 90 nop <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _Thread_Restart( the_thread, NULL, argument ) ) { _Thread_Enable_dispatch(); 10b14c: e8 8f 1b 00 00 call 10cce0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b151: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b153: c9 leave <== NOT EXECUTED 10b154: c3 ret <== NOT EXECUTED 0010b930 : */ rtems_status_code rtems_task_resume( Objects_Id id ) { 10b930: 55 push %ebp <== NOT EXECUTED 10b931: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b933: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10b936: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b939: 50 push %eax <== NOT EXECUTED 10b93a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b93d: e8 82 1e 00 00 call 10d7c4 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10b942: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b945: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10b948: 85 d2 test %edx,%edx <== NOT EXECUTED 10b94a: 74 08 je 10b954 <== NOT EXECUTED 10b94c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b951: c9 leave <== NOT EXECUTED 10b952: c3 ret <== NOT EXECUTED 10b953: 90 nop <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { 10b954: f6 40 10 02 testb $0x2,0x10(%eax) <== NOT EXECUTED 10b958: 75 0e jne 10b968 <== NOT EXECUTED _Thread_Resume( the_thread, TRUE ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10b95a: e8 15 1e 00 00 call 10d774 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b95f: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b964: c9 leave <== NOT EXECUTED 10b965: c3 ret <== NOT EXECUTED 10b966: 66 90 xchg %ax,%ax <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { _Thread_Resume( the_thread, TRUE ); 10b968: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b96b: 6a 01 push $0x1 <== NOT EXECUTED 10b96d: 50 push %eax <== NOT EXECUTED 10b96e: e8 75 26 00 00 call 10dfe8 <_Thread_Resume> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b973: e8 fc 1d 00 00 call 10d774 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b978: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b97a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b97d: c9 leave <== NOT EXECUTED 10b97e: c3 ret <== NOT EXECUTED 00125f70 : #include #include rtems_id rtems_task_self(void) { 125f70: 55 push %ebp <== NOT EXECUTED 125f71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125f73: a1 dc 12 16 00 mov 0x1612dc,%eax <== NOT EXECUTED 125f78: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED return _Thread_Executing->Object.id; } 125f7b: c9 leave <== NOT EXECUTED 125f7c: c3 ret <== NOT EXECUTED 0010bf74 : rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) { 10bf74: 55 push %ebp <== NOT EXECUTED 10bf75: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bf77: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10bf7a: a1 b4 29 12 00 mov 0x1229b4,%eax <== NOT EXECUTED 10bf7f: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10bf82: 80 78 04 00 cmpb $0x0,0x4(%eax) <== NOT EXECUTED 10bf86: 74 54 je 10bfdc <== 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 ) 10bf88: 83 7d 0c 0f cmpl $0xf,0xc(%ebp) <== NOT EXECUTED 10bf8c: 77 46 ja 10bfd4 <== NOT EXECUTED /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10bf8e: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10bf91: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bf93: 74 4f je 10bfe4 <== NOT EXECUTED 10bf95: a1 dc 29 12 00 mov 0x1229dc,%eax <== NOT EXECUTED 10bf9a: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bf9d: 3b 50 08 cmp 0x8(%eax),%edx <== NOT EXECUTED 10bfa0: 74 47 je 10bfe9 <== NOT EXECUTED api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10bfa2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bfa5: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10bfa8: 50 push %eax <== NOT EXECUTED 10bfa9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bfac: e8 6f 1d 00 00 call 10dd20 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10bfb1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bfb4: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10bfb7: 85 d2 test %edx,%edx <== NOT EXECUTED 10bfb9: 75 45 jne 10c000 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10bfbb: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10bfc1: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10bfc4: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10bfc7: 89 54 88 20 mov %edx,0x20(%eax,%ecx,4) <== NOT EXECUTED _Thread_Enable_dispatch(); 10bfcb: e8 2c 1d 00 00 call 10dcfc <_Thread_Enable_dispatch> <== NOT EXECUTED 10bfd0: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bfd2: c9 leave <== NOT EXECUTED 10bfd3: c3 ret <== 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 ) 10bfd4: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bfd9: c9 leave <== NOT EXECUTED 10bfda: c3 ret <== NOT EXECUTED 10bfdb: 90 nop <== NOT EXECUTED { register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10bfdc: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bfe1: c9 leave <== NOT EXECUTED 10bfe2: c3 ret <== NOT EXECUTED 10bfe3: 90 nop <== NOT EXECUTED 10bfe4: a1 dc 29 12 00 mov 0x1229dc,%eax <== NOT EXECUTED */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10bfe9: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10bfef: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10bff2: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10bff5: 89 54 88 20 mov %edx,0x20(%eax,%ecx,4) <== NOT EXECUTED 10bff9: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bffb: c9 leave <== NOT EXECUTED 10bffc: c3 ret <== NOT EXECUTED 10bffd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 10c000: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c005: c9 leave <== NOT EXECUTED 10c006: c3 ret <== NOT EXECUTED 0010f434 : rtems_status_code rtems_task_set_priority( Objects_Id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10f434: 55 push %ebp <== NOT EXECUTED 10f435: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f437: 56 push %esi <== NOT EXECUTED 10f438: 53 push %ebx <== NOT EXECUTED 10f439: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10f43c: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10f43f: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10f442: 85 db test %ebx,%ebx <== NOT EXECUTED 10f444: 74 0b je 10f451 <== NOT EXECUTED bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ); 10f446: 0f b6 05 f4 72 12 00 movzbl 0x1272f4,%eax <== NOT EXECUTED 10f44d: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10f44f: 77 5f ja 10f4b0 <== NOT EXECUTED !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 10f451: 85 f6 test %esi,%esi <== NOT EXECUTED 10f453: 74 67 je 10f4bc <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10f455: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f458: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10f45b: 50 push %eax <== NOT EXECUTED 10f45c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f45f: e8 a0 1c 00 00 call 111104 <_Thread_Get> <== NOT EXECUTED 10f464: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 10f466: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f469: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 10f46c: 85 c0 test %eax,%eax <== NOT EXECUTED 10f46e: 74 0c je 10f47c <== NOT EXECUTED 10f470: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f475: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f478: 5b pop %ebx <== NOT EXECUTED 10f479: 5e pop %esi <== NOT EXECUTED 10f47a: c9 leave <== NOT EXECUTED 10f47b: c3 ret <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10f47c: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED 10f47f: 89 06 mov %eax,(%esi) <== NOT EXECUTED if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10f481: 85 db test %ebx,%ebx <== NOT EXECUTED 10f483: 74 1c je 10f4a1 <== NOT EXECUTED the_thread->real_priority = new_priority; 10f485: 89 5a 18 mov %ebx,0x18(%edx) <== NOT EXECUTED if ( the_thread->resource_count == 0 || 10f488: 8b 4a 1c mov 0x1c(%edx),%ecx <== NOT EXECUTED 10f48b: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f48d: 74 05 je 10f494 <== NOT EXECUTED 10f48f: 3b 5a 14 cmp 0x14(%edx),%ebx <== NOT EXECUTED 10f492: 73 0d jae 10f4a1 <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, FALSE ); 10f494: 50 push %eax <== NOT EXECUTED 10f495: 6a 00 push $0x0 <== NOT EXECUTED 10f497: 53 push %ebx <== NOT EXECUTED 10f498: 52 push %edx <== NOT EXECUTED 10f499: e8 3a 17 00 00 call 110bd8 <_Thread_Change_priority> <== NOT EXECUTED 10f49e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _Thread_Enable_dispatch(); 10f4a1: e8 0e 1c 00 00 call 1110b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10f4a6: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f4a8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f4ab: 5b pop %ebx <== NOT EXECUTED 10f4ac: 5e pop %esi <== NOT EXECUTED 10f4ad: c9 leave <== NOT EXECUTED 10f4ae: c3 ret <== NOT EXECUTED 10f4af: 90 nop <== NOT EXECUTED 10f4b0: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED 10f4b5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f4b8: 5b pop %ebx <== NOT EXECUTED 10f4b9: 5e pop %esi <== NOT EXECUTED 10f4ba: c9 leave <== NOT EXECUTED 10f4bb: c3 ret <== NOT EXECUTED if ( new_priority != RTEMS_CURRENT_PRIORITY && !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 10f4bc: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f4c1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f4c4: 5b pop %ebx <== NOT EXECUTED 10f4c5: 5e pop %esi <== NOT EXECUTED 10f4c6: c9 leave <== NOT EXECUTED 10f4c7: c3 ret <== NOT EXECUTED 0010a7e4 : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 10a7e4: 55 push %ebp <== NOT EXECUTED 10a7e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a7e7: 53 push %ebx <== NOT EXECUTED 10a7e8: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10a7eb: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 10a7ee: 85 db test %ebx,%ebx <== NOT EXECUTED 10a7f0: 74 5a je 10a84c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10a7f2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a7f5: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a7f8: 50 push %eax <== NOT EXECUTED 10a7f9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a7fc: e8 cb 1a 00 00 call 10c2cc <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10a801: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a804: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10a807: 85 d2 test %edx,%edx <== NOT EXECUTED 10a809: 74 0d je 10a818 <== NOT EXECUTED 10a80b: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a810: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a813: c9 leave <== NOT EXECUTED 10a814: c3 ret <== NOT EXECUTED 10a815: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _Thread_Start( 10a818: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a81b: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10a81e: 6a 00 push $0x0 <== NOT EXECUTED 10a820: 53 push %ebx <== NOT EXECUTED 10a821: 6a 00 push $0x0 <== NOT EXECUTED 10a823: 50 push %eax <== NOT EXECUTED 10a824: e8 7b 25 00 00 call 10cda4 <_Thread_Start> <== NOT EXECUTED 10a829: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10a82c: 84 c0 test %al,%al <== NOT EXECUTED 10a82e: 75 10 jne 10a840 <== NOT EXECUTED the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10a830: e8 73 1a 00 00 call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a835: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a83a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a83d: c9 leave <== NOT EXECUTED 10a83e: c3 ret <== NOT EXECUTED 10a83f: 90 nop <== NOT EXECUTED switch ( location ) { case OBJECTS_LOCAL: if ( _Thread_Start( the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); 10a840: e8 63 1a 00 00 call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a845: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a847: eb c7 jmp 10a810 <== NOT EXECUTED 10a849: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 10a84c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a851: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a854: c9 leave <== NOT EXECUTED 10a855: c3 ret <== NOT EXECUTED 0010b9f4 : */ rtems_status_code rtems_task_suspend( Objects_Id id ) { 10b9f4: 55 push %ebp <== NOT EXECUTED 10b9f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b9f7: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10b9fa: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b9fd: 50 push %eax <== NOT EXECUTED 10b9fe: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ba01: e8 be 1d 00 00 call 10d7c4 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10ba06: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ba09: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10ba0c: 85 d2 test %edx,%edx <== NOT EXECUTED 10ba0e: 74 08 je 10ba18 <== NOT EXECUTED 10ba10: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ba15: c9 leave <== NOT EXECUTED 10ba16: c3 ret <== NOT EXECUTED 10ba17: 90 nop <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 10ba18: f6 40 10 02 testb $0x2,0x10(%eax) <== NOT EXECUTED 10ba1c: 74 0e je 10ba2c <== NOT EXECUTED _Thread_Suspend( the_thread ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10ba1e: e8 51 1d 00 00 call 10d774 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ba23: b8 0f 00 00 00 mov $0xf,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ba28: c9 leave <== NOT EXECUTED 10ba29: c3 ret <== NOT EXECUTED 10ba2a: 66 90 xchg %ax,%ax <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { _Thread_Suspend( the_thread ); 10ba2c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ba2f: 50 push %eax <== NOT EXECUTED 10ba30: e8 77 29 00 00 call 10e3ac <_Thread_Suspend> <== NOT EXECUTED _Thread_Enable_dispatch(); 10ba35: e8 3a 1d 00 00 call 10d774 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ba3a: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ba3c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ba3f: c9 leave <== NOT EXECUTED 10ba40: c3 ret <== NOT EXECUTED 00126184 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 126184: 55 push %ebp <== NOT EXECUTED 126185: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126187: 56 push %esi <== NOT EXECUTED 126188: 53 push %ebx <== NOT EXECUTED 126189: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 12618c: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 12618f: 85 db test %ebx,%ebx <== NOT EXECUTED 126191: 0f 84 a1 00 00 00 je 126238 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 126197: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12619a: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 12619d: 50 push %eax <== NOT EXECUTED 12619e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1261a1: e8 52 b5 fe ff call 1116f8 <_Thread_Get> <== NOT EXECUTED 1261a6: 89 c6 mov %eax,%esi <== NOT EXECUTED switch (location) { 1261a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1261ab: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 1261ae: 85 c0 test %eax,%eax <== NOT EXECUTED 1261b0: 75 2e jne 1261e0 <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 1261b2: 8b 86 04 01 00 00 mov 0x104(%esi),%eax <== NOT EXECUTED while (tvp) { 1261b8: 85 c0 test %eax,%eax <== NOT EXECUTED 1261ba: 75 0a jne 1261c6 <== NOT EXECUTED 1261bc: eb 2e jmp 1261ec <== NOT EXECUTED 1261be: 66 90 xchg %ax,%ax <== NOT EXECUTED if (tvp->ptr == ptr) { tvp->dtor = dtor; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 1261c0: 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) { 1261c2: 85 c0 test %eax,%eax <== NOT EXECUTED 1261c4: 74 26 je 1261ec <== NOT EXECUTED if (tvp->ptr == ptr) { 1261c6: 39 58 04 cmp %ebx,0x4(%eax) <== NOT EXECUTED 1261c9: 75 f5 jne 1261c0 <== NOT EXECUTED tvp->dtor = dtor; 1261cb: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 1261ce: 89 50 10 mov %edx,0x10(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 1261d1: e8 fe b4 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 1261d6: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1261d8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1261db: 5b pop %ebx <== NOT EXECUTED 1261dc: 5e pop %esi <== NOT EXECUTED 1261dd: c9 leave <== NOT EXECUTED 1261de: c3 ret <== NOT EXECUTED 1261df: 90 nop <== NOT EXECUTED if ( !ptr ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 1261e0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1261e5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1261e8: 5b pop %ebx <== NOT EXECUTED 1261e9: 5e pop %esi <== NOT EXECUTED 1261ea: c9 leave <== NOT EXECUTED 1261eb: c3 ret <== NOT EXECUTED } /* * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) 1261ec: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1261ef: 6a 14 push $0x14 <== NOT EXECUTED 1261f1: e8 12 c6 fe ff call 112808 <_Workspace_Allocate> <== NOT EXECUTED 1261f6: 89 c2 mov %eax,%edx <== NOT EXECUTED _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 1261f8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1261fb: 85 c0 test %eax,%eax <== NOT EXECUTED 1261fd: 74 2d je 12622c <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 1261ff: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 126201: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED new->ptr = ptr; 126204: 89 5a 04 mov %ebx,0x4(%edx) <== NOT EXECUTED new->dtor = dtor; 126207: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 12620a: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 12620d: 8b 86 04 01 00 00 mov 0x104(%esi),%eax <== NOT EXECUTED 126213: 89 02 mov %eax,(%edx) <== NOT EXECUTED the_thread->task_variables = new; 126215: 89 96 04 01 00 00 mov %edx,0x104(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 12621b: e8 b4 b4 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 126220: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126222: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126225: 5b pop %ebx <== NOT EXECUTED 126226: 5e pop %esi <== NOT EXECUTED 126227: c9 leave <== NOT EXECUTED 126228: c3 ret <== NOT EXECUTED 126229: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { _Thread_Enable_dispatch(); 12622c: e8 a3 b4 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 126231: b8 1a 00 00 00 mov $0x1a,%eax <== NOT EXECUTED 126236: eb ad jmp 1261e5 <== NOT EXECUTED { Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 126238: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12623d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126240: 5b pop %ebx <== NOT EXECUTED 126241: 5e pop %esi <== NOT EXECUTED 126242: c9 leave <== NOT EXECUTED 126243: c3 ret <== NOT EXECUTED 00126244 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 126244: 55 push %ebp <== NOT EXECUTED 126245: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126247: 56 push %esi <== NOT EXECUTED 126248: 53 push %ebx <== NOT EXECUTED 126249: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 12624c: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 12624f: 85 db test %ebx,%ebx <== NOT EXECUTED 126251: 74 3f je 126292 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); 126253: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 126256: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 126259: 50 push %eax <== NOT EXECUTED 12625a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12625d: e8 96 b4 fe ff call 1116f8 <_Thread_Get> <== NOT EXECUTED 126262: 89 c6 mov %eax,%esi <== NOT EXECUTED switch (location) { 126264: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126267: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 12626a: 85 c0 test %eax,%eax <== NOT EXECUTED 12626c: 75 32 jne 1262a0 <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; 12626e: 8b 96 04 01 00 00 mov 0x104(%esi),%edx <== NOT EXECUTED while (tvp) { 126274: 85 d2 test %edx,%edx <== NOT EXECUTED 126276: 74 15 je 12628d <== NOT EXECUTED if (tvp->ptr == ptr) { 126278: 39 5a 04 cmp %ebx,0x4(%edx) <== NOT EXECUTED 12627b: 75 08 jne 126285 <== NOT EXECUTED 12627d: eb 4c jmp 1262cb <== NOT EXECUTED 12627f: 90 nop <== NOT EXECUTED 126280: 39 5a 04 cmp %ebx,0x4(%edx) <== NOT EXECUTED 126283: 74 27 je 1262ac <== NOT EXECUTED else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 126285: 89 d1 mov %edx,%ecx <== NOT EXECUTED } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 126287: 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) { 126289: 85 d2 test %edx,%edx <== NOT EXECUTED 12628b: 75 f3 jne 126280 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 12628d: e8 42 b4 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 126292: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126297: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12629a: 5b pop %ebx <== NOT EXECUTED 12629b: 5e pop %esi <== NOT EXECUTED 12629c: c9 leave <== NOT EXECUTED 12629d: c3 ret <== NOT EXECUTED 12629e: 66 90 xchg %ax,%ax <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); switch (location) { 1262a0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1262a5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1262a8: 5b pop %ebx <== NOT EXECUTED 1262a9: 5e pop %esi <== NOT EXECUTED 1262aa: c9 leave <== NOT EXECUTED 1262ab: c3 ret <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; 1262ac: 8b 02 mov (%edx),%eax <== NOT EXECUTED 1262ae: 89 01 mov %eax,(%ecx) <== NOT EXECUTED else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); 1262b0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1262b3: 52 push %edx <== NOT EXECUTED 1262b4: 56 push %esi <== NOT EXECUTED 1262b5: e8 a6 00 00 00 call 126360 <_RTEMS_Tasks_Invoke_task_variable_dtor> <== NOT EXECUTED _Thread_Enable_dispatch(); 1262ba: e8 15 b4 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 1262bf: 31 c0 xor %eax,%eax <== NOT EXECUTED 1262c1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1262c4: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1262c7: 5b pop %ebx <== NOT EXECUTED 1262c8: 5e pop %esi <== NOT EXECUTED 1262c9: c9 leave <== NOT EXECUTED 1262ca: c3 ret <== NOT EXECUTED while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 1262cb: 8b 02 mov (%edx),%eax <== NOT EXECUTED 1262cd: 89 86 04 01 00 00 mov %eax,0x104(%esi) <== NOT EXECUTED 1262d3: eb db jmp 1262b0 <== NOT EXECUTED 001262d8 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 1262d8: 55 push %ebp <== NOT EXECUTED 1262d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1262db: 56 push %esi <== NOT EXECUTED 1262dc: 53 push %ebx <== NOT EXECUTED 1262dd: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 1262e0: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 1262e3: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 1262e6: 85 db test %ebx,%ebx <== NOT EXECUTED 1262e8: 74 56 je 126340 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !result ) 1262ea: 85 f6 test %esi,%esi <== NOT EXECUTED 1262ec: 74 52 je 126340 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 1262ee: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1262f1: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1262f4: 50 push %eax <== NOT EXECUTED 1262f5: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1262f8: e8 fb b3 fe ff call 1116f8 <_Thread_Get> <== NOT EXECUTED switch (location) { 1262fd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126300: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 126303: 85 d2 test %edx,%edx <== NOT EXECUTED 126305: 75 2d jne 126334 <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 126307: 8b 80 04 01 00 00 mov 0x104(%eax),%eax <== NOT EXECUTED while (tvp) { 12630d: 85 c0 test %eax,%eax <== NOT EXECUTED 12630f: 75 09 jne 12631a <== NOT EXECUTED 126311: eb 39 jmp 12634c <== NOT EXECUTED 126313: 90 nop <== NOT EXECUTED */ *result = tvp->tval; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 126314: 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) { 126316: 85 c0 test %eax,%eax <== NOT EXECUTED 126318: 74 32 je 12634c <== NOT EXECUTED if (tvp->ptr == ptr) { 12631a: 39 58 04 cmp %ebx,0x4(%eax) <== NOT EXECUTED 12631d: 75 f5 jne 126314 <== NOT EXECUTED /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 12631f: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 126322: 89 06 mov %eax,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 126324: e8 ab b3 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 126329: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12632b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12632e: 5b pop %ebx <== NOT EXECUTED 12632f: 5e pop %esi <== NOT EXECUTED 126330: c9 leave <== NOT EXECUTED 126331: c3 ret <== NOT EXECUTED 126332: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !result ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 126334: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126339: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12633c: 5b pop %ebx <== NOT EXECUTED 12633d: 5e pop %esi <== NOT EXECUTED 12633e: c9 leave <== NOT EXECUTED 12633f: c3 ret <== NOT EXECUTED return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; 126340: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126345: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126348: 5b pop %ebx <== NOT EXECUTED 126349: 5e pop %esi <== NOT EXECUTED 12634a: c9 leave <== NOT EXECUTED 12634b: c3 ret <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 12634c: e8 83 b3 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 126351: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126356: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126359: 5b pop %ebx <== NOT EXECUTED 12635a: 5e pop %esi <== NOT EXECUTED 12635b: c9 leave <== NOT EXECUTED 12635c: c3 ret <== NOT EXECUTED 0010a858 : */ rtems_status_code rtems_task_wake_after( rtems_interval ticks ) { 10a858: 55 push %ebp <== NOT EXECUTED 10a859: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a85b: 53 push %ebx <== NOT EXECUTED 10a85c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a85f: 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 10a862: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10a867: 40 inc %eax <== NOT EXECUTED 10a868: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED _Thread_Disable_dispatch(); if ( ticks == 0 ) { 10a86d: 85 db test %ebx,%ebx <== NOT EXECUTED 10a86f: 74 53 je 10a8c4 <== NOT EXECUTED _Thread_Yield_processor(); } else { _Thread_Set_state( _Thread_Executing, STATES_DELAYING ); 10a871: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a874: 6a 08 push $0x8 <== NOT EXECUTED 10a876: ff 35 bc ea 11 00 pushl 0x11eabc <== NOT EXECUTED 10a87c: e8 db 22 00 00 call 10cb5c <_Thread_Set_state> <== NOT EXECUTED _Watchdog_Initialize( 10a881: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED 10a886: 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. * 10a889: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10a890: c7 40 64 10 c1 10 00 movl $0x10c110,0x64(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10a897: 89 50 68 mov %edx,0x68(%eax) <== NOT EXECUTED * the heap 10a89a: 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, 10a8a1: 89 58 54 mov %ebx,0x54(%eax) <== NOT EXECUTED void *starting_address, size_t *size 10a8a4: 5a pop %edx <== NOT EXECUTED 10a8a5: 59 pop %ecx <== NOT EXECUTED 10a8a6: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 10a8a9: 50 push %eax <== NOT EXECUTED 10a8aa: 68 dc ea 11 00 push $0x11eadc <== NOT EXECUTED 10a8af: e8 04 29 00 00 call 10d1b8 <_Watchdog_Insert> <== NOT EXECUTED 10a8b4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); } _Thread_Enable_dispatch(); 10a8b7: e8 ec 19 00 00 call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10a8bc: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a8be: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a8c1: c9 leave <== NOT EXECUTED 10a8c2: c3 ret <== NOT EXECUTED 10a8c3: 90 nop <== NOT EXECUTED rtems_interval ticks ) { _Thread_Disable_dispatch(); if ( ticks == 0 ) { _Thread_Yield_processor(); 10a8c4: e8 a7 25 00 00 call 10ce70 <_Thread_Yield_processor> <== NOT EXECUTED _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); } _Thread_Enable_dispatch(); 10a8c9: e8 da 19 00 00 call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10a8ce: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a8d0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a8d3: c9 leave <== NOT EXECUTED 10a8d4: c3 ret <== NOT EXECUTED 0010b4e0 : */ rtems_status_code rtems_task_wake_when( rtems_time_of_day *time_buffer ) { 10b4e0: 55 push %ebp <== NOT EXECUTED 10b4e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4e3: 53 push %ebx <== NOT EXECUTED 10b4e4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b4e7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Watchdog_Interval seconds; if ( !_TOD_Is_set ) 10b4ea: 80 3d cc 16 12 00 00 cmpb $0x0,0x1216cc <== NOT EXECUTED 10b4f1: 0f 84 a1 00 00 00 je 10b598 <== NOT EXECUTED return RTEMS_NOT_DEFINED; if ( !time_buffer ) 10b4f7: 85 db test %ebx,%ebx <== NOT EXECUTED 10b4f9: 0f 84 a5 00 00 00 je 10b5a4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; time_buffer->ticks = 0; 10b4ff: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED if ( !_TOD_Validate( time_buffer ) ) 10b506: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b509: 53 push %ebx <== NOT EXECUTED 10b50a: e8 c1 f3 ff ff call 10a8d0 <_TOD_Validate> <== NOT EXECUTED 10b50f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b512: 84 c0 test %al,%al <== NOT EXECUTED 10b514: 75 0a jne 10b520 <== NOT EXECUTED _Watchdog_Insert_seconds( &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 10b516: b8 14 00 00 00 mov $0x14,%eax <== NOT EXECUTED } 10b51b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b51e: c9 leave <== NOT EXECUTED 10b51f: c3 ret <== NOT EXECUTED time_buffer->ticks = 0; if ( !_TOD_Validate( time_buffer ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); 10b520: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b523: 53 push %ebx <== NOT EXECUTED 10b524: e8 17 f3 ff ff call 10a840 <_TOD_To_seconds> <== NOT EXECUTED 10b529: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( seconds <= _TOD_Seconds_since_epoch ) 10b52b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b52e: 3b 05 4c 17 12 00 cmp 0x12174c,%eax <== NOT EXECUTED 10b534: 76 e0 jbe 10b516 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10b536: a1 b8 16 12 00 mov 0x1216b8,%eax <== NOT EXECUTED 10b53b: 40 inc %eax <== NOT EXECUTED 10b53c: a3 b8 16 12 00 mov %eax,0x1216b8 <== NOT EXECUTED return RTEMS_INVALID_CLOCK; _Thread_Disable_dispatch(); _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME ); 10b541: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b544: 6a 10 push $0x10 <== NOT EXECUTED 10b546: ff 35 7c 17 12 00 pushl 0x12177c <== NOT EXECUTED 10b54c: e8 7f 23 00 00 call 10d8d0 <_Thread_Set_state> <== NOT EXECUTED _Watchdog_Initialize( 10b551: a1 7c 17 12 00 mov 0x12177c,%eax <== NOT EXECUTED 10b556: 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. * 10b559: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10b560: c7 40 64 84 ce 10 00 movl $0x10ce84,0x64(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10b567: 89 50 68 mov %edx,0x68(%eax) <== NOT EXECUTED * the heap 10b56a: 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, 10b571: 2b 1d 4c 17 12 00 sub 0x12174c,%ebx <== NOT EXECUTED 10b577: 89 58 54 mov %ebx,0x54(%eax) <== NOT EXECUTED size_t size ); 10b57a: 5a pop %edx <== NOT EXECUTED 10b57b: 59 pop %ecx <== NOT EXECUTED 10b57c: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 10b57f: 50 push %eax <== NOT EXECUTED 10b580: 68 90 17 12 00 push $0x121790 <== NOT EXECUTED 10b585: e8 1e 2a 00 00 call 10dfa8 <_Watchdog_Insert> <== NOT EXECUTED ); _Watchdog_Insert_seconds( &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); 10b58a: e8 8d 1a 00 00 call 10d01c <_Thread_Enable_dispatch> <== NOT EXECUTED 10b58f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b591: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b594: eb 85 jmp 10b51b <== NOT EXECUTED 10b596: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_time_of_day *time_buffer ) { Watchdog_Interval seconds; if ( !_TOD_Is_set ) 10b598: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b59d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b5a0: c9 leave <== NOT EXECUTED 10b5a1: c3 ret <== NOT EXECUTED 10b5a2: 66 90 xchg %ax,%ax <== NOT EXECUTED Watchdog_Interval seconds; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !time_buffer ) 10b5a4: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b5a9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b5ac: c9 leave <== NOT EXECUTED 10b5ad: c3 ret <== NOT EXECUTED 00114404 : */ rtems_status_code rtems_timer_cancel( Objects_Id id ) { 114404: 55 push %ebp <== NOT EXECUTED 114405: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114407: 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 11440a: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 11440d: 50 push %eax <== NOT EXECUTED 11440e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114411: 68 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 114416: e8 81 27 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 11441b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11441e: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 114421: 85 d2 test %edx,%edx <== NOT EXECUTED 114423: 74 07 je 11442c <== NOT EXECUTED 114425: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11442a: c9 leave <== NOT EXECUTED 11442b: c3 ret <== NOT EXECUTED the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 11442c: 83 78 38 04 cmpl $0x4,0x38(%eax) <== NOT EXECUTED 114430: 74 0f je 114441 <== NOT EXECUTED (void) _Watchdog_Remove( &the_timer->Ticker ); 114432: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114435: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 114438: 50 push %eax <== NOT EXECUTED 114439: e8 9a 43 00 00 call 1187d8 <_Watchdog_Remove> <== NOT EXECUTED 11443e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Enable_dispatch(); 114441: e8 9a 2f 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 114446: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114448: c9 leave <== NOT EXECUTED 114449: c3 ret <== NOT EXECUTED 0011444c : rtems_status_code rtems_timer_create( rtems_name name, Objects_Id *id ) { 11444c: 55 push %ebp <== NOT EXECUTED 11444d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11444f: 57 push %edi <== NOT EXECUTED 114450: 56 push %esi <== NOT EXECUTED 114451: 53 push %ebx <== NOT EXECUTED 114452: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114455: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 114458: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 11445b: 85 f6 test %esi,%esi <== NOT EXECUTED 11445d: 74 71 je 1144d0 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 11445f: 85 ff test %edi,%edi <== NOT EXECUTED 114461: 0f 84 8d 00 00 00 je 1144f4 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 114467: a1 f8 5a 13 00 mov 0x135af8,%eax <== NOT EXECUTED 11446c: 40 inc %eax <== NOT EXECUTED 11446d: a3 f8 5a 13 00 mov %eax,0x135af8 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 114472: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114475: 68 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 11447a: e8 e9 21 00 00 call 116668 <_Objects_Allocate> <== NOT EXECUTED 11447f: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { 114481: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114484: 85 c0 test %eax,%eax <== NOT EXECUTED 114486: 74 58 je 1144e0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_timer->the_class = TIMER_DORMANT; 114488: 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. * 11448f: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 114496: 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 11449d: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) <== NOT EXECUTED * the heap 1144a4: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) <== NOT EXECUTED 1144ab: 8b 48 08 mov 0x8(%eax),%ecx <== NOT EXECUTED 1144ae: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 1144b1: a1 7c 5e 13 00 mov 0x135e7c,%eax <== NOT EXECUTED 1144b6: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 1144b9: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Timer_Information, &the_timer->Object, (Objects_Name) name ); *id = the_timer->Object.id; 1144bc: 89 0f mov %ecx,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 1144be: e8 1d 2f 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 1144c3: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 1144c5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1144c8: 5b pop %ebx <== NOT EXECUTED 1144c9: 5e pop %esi <== NOT EXECUTED 1144ca: 5f pop %edi <== NOT EXECUTED 1144cb: c9 leave <== NOT EXECUTED 1144cc: c3 ret <== NOT EXECUTED 1144cd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED Objects_Id *id ) { Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 1144d0: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1144d5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1144d8: 5b pop %ebx <== NOT EXECUTED 1144d9: 5e pop %esi <== NOT EXECUTED 1144da: 5f pop %edi <== NOT EXECUTED 1144db: c9 leave <== NOT EXECUTED 1144dc: c3 ret <== NOT EXECUTED 1144dd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { _Thread_Enable_dispatch(); 1144e0: e8 fb 2e 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 1144e5: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1144ea: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1144ed: 5b pop %ebx <== NOT EXECUTED 1144ee: 5e pop %esi <== NOT EXECUTED 1144ef: 5f pop %edi <== NOT EXECUTED 1144f0: c9 leave <== NOT EXECUTED 1144f1: c3 ret <== NOT EXECUTED 1144f2: 66 90 xchg %ax,%ax <== NOT EXECUTED Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 1144f4: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1144f9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1144fc: 5b pop %ebx <== NOT EXECUTED 1144fd: 5e pop %esi <== NOT EXECUTED 1144fe: 5f pop %edi <== NOT EXECUTED 1144ff: c9 leave <== NOT EXECUTED 114500: c3 ret <== NOT EXECUTED 00114504 : */ rtems_status_code rtems_timer_delete( Objects_Id id ) { 114504: 55 push %ebp <== NOT EXECUTED 114505: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114507: 53 push %ebx <== NOT EXECUTED 114508: 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 11450b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 11450e: 50 push %eax <== NOT EXECUTED 11450f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114512: 68 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 114517: e8 80 26 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED 11451c: 89 c3 mov %eax,%ebx <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 11451e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114521: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 114524: 85 c9 test %ecx,%ecx <== NOT EXECUTED 114526: 75 38 jne 114560 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Timer_Information, &the_timer->Object ); 114528: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11452b: 50 push %eax <== NOT EXECUTED 11452c: 68 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 114531: e8 b2 21 00 00 call 1166e8 <_Objects_Close> <== NOT EXECUTED (void) _Watchdog_Remove( &the_timer->Ticker ); 114536: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 114539: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 11453c: e8 97 42 00 00 call 1187d8 <_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 114541: 58 pop %eax <== NOT EXECUTED 114542: 5a pop %edx <== NOT EXECUTED 114543: 53 push %ebx <== NOT EXECUTED 114544: 68 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 114549: e8 da 24 00 00 call 116a28 <_Objects_Free> <== NOT EXECUTED _Timer_Free( the_timer ); _Thread_Enable_dispatch(); 11454e: e8 8d 2e 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 114553: 31 c0 xor %eax,%eax <== NOT EXECUTED 114555: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114558: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11455b: c9 leave <== NOT EXECUTED 11455c: c3 ret <== NOT EXECUTED 11455d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 114560: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114565: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114568: c9 leave <== NOT EXECUTED 114569: c3 ret <== NOT EXECUTED 0011456c : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 11456c: 55 push %ebp <== NOT EXECUTED 11456d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11456f: 57 push %edi <== NOT EXECUTED 114570: 56 push %esi <== NOT EXECUTED 114571: 53 push %ebx <== NOT EXECUTED 114572: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 114575: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 114578: 85 f6 test %esi,%esi <== NOT EXECUTED 11457a: 0f 84 98 00 00 00 je 114618 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; if ( !routine ) 114580: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 114583: 85 ff test %edi,%edi <== NOT EXECUTED 114585: 0f 84 9d 00 00 00 je 114628 <== 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 11458b: 53 push %ebx <== NOT EXECUTED 11458c: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 11458f: 50 push %eax <== NOT EXECUTED 114590: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114593: 68 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 114598: e8 ff 25 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED 11459d: 89 c3 mov %eax,%ebx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 11459f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1145a2: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 1145a5: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1145a7: 75 5f jne 114608 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 1145a9: 8d 78 10 lea 0x10(%eax),%edi <== NOT EXECUTED 1145ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1145af: 57 push %edi <== NOT EXECUTED 1145b0: e8 23 42 00 00 call 1187d8 <_Watchdog_Remove> <== NOT EXECUTED _ISR_Disable( level ); 1145b5: 9c pushf <== NOT EXECUTED 1145b6: fa cli <== NOT EXECUTED 1145b7: 58 pop %eax <== 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 ) { 1145b8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1145bb: 8b 53 18 mov 0x18(%ebx),%edx <== NOT EXECUTED 1145be: 85 d2 test %edx,%edx <== NOT EXECUTED 1145c0: 75 76 jne 114638 <== 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; 1145c2: 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. * 1145c9: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 1145d0: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 1145d3: 89 53 2c mov %edx,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 1145d6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1145d9: 89 53 30 mov %edx,0x30(%ebx) <== NOT EXECUTED * the heap 1145dc: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 1145df: 89 53 34 mov %edx,0x34(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 1145e2: 50 push %eax <== NOT EXECUTED 1145e3: 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, 1145e4: 89 73 1c mov %esi,0x1c(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 1145e7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1145ea: 57 push %edi <== NOT EXECUTED 1145eb: 68 dc 5b 13 00 push $0x135bdc <== NOT EXECUTED 1145f0: e8 b3 40 00 00 call 1186a8 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 1145f5: e8 e6 2d 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 1145fa: 31 c0 xor %eax,%eax <== NOT EXECUTED 1145fc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1145ff: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 114602: 5b pop %ebx <== NOT EXECUTED 114603: 5e pop %esi <== NOT EXECUTED 114604: 5f pop %edi <== NOT EXECUTED 114605: c9 leave <== NOT EXECUTED 114606: c3 ret <== NOT EXECUTED 114607: 90 nop <== NOT EXECUTED if ( !routine ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 114608: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11460d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 114610: 5b pop %ebx <== NOT EXECUTED 114611: 5e pop %esi <== NOT EXECUTED 114612: 5f pop %edi <== NOT EXECUTED 114613: c9 leave <== NOT EXECUTED 114614: c3 ret <== NOT EXECUTED 114615: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 114618: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11461d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 114620: 5b pop %ebx <== NOT EXECUTED 114621: 5e pop %esi <== NOT EXECUTED 114622: 5f pop %edi <== NOT EXECUTED 114623: c9 leave <== NOT EXECUTED 114624: c3 ret <== NOT EXECUTED 114625: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ISR_Level level; if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; if ( !routine ) 114628: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11462d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 114630: 5b pop %ebx <== NOT EXECUTED 114631: 5e pop %esi <== NOT EXECUTED 114632: 5f pop %edi <== NOT EXECUTED 114633: c9 leave <== NOT EXECUTED 114634: c3 ret <== NOT EXECUTED 114635: 8d 76 00 lea 0x0(%esi),%esi <== 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 ) { _ISR_Enable( level ); 114638: 50 push %eax <== NOT EXECUTED 114639: 9d popf <== NOT EXECUTED _Thread_Enable_dispatch(); 11463a: e8 a1 2d 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 11463f: 31 c0 xor %eax,%eax 114641: eb ca jmp 11460d <== NOT EXECUTED 00114644 : Objects_Id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 114644: 55 push %ebp <== NOT EXECUTED 114645: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114647: 57 push %edi <== NOT EXECUTED 114648: 56 push %esi <== NOT EXECUTED 114649: 53 push %ebx <== NOT EXECUTED 11464a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD_Is_set ) 11464d: 80 3d 0c 5b 13 00 00 cmpb $0x0,0x135b0c <== NOT EXECUTED 114654: 75 0e jne 114664 <== NOT EXECUTED 114656: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11465b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11465e: 5b pop %ebx <== NOT EXECUTED 11465f: 5e pop %esi <== NOT EXECUTED 114660: 5f pop %edi <== NOT EXECUTED 114661: c9 leave <== NOT EXECUTED 114662: c3 ret <== NOT EXECUTED 114663: 90 nop <== NOT EXECUTED rtems_interval seconds; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !_TOD_Validate( wall_time ) ) 114664: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114667: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11466a: e8 d1 d6 ff ff call 111d40 <_TOD_Validate> <== NOT EXECUTED 11466f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114672: 84 c0 test %al,%al <== NOT EXECUTED 114674: 74 23 je 114699 <== NOT EXECUTED return RTEMS_INVALID_CLOCK; if ( !routine ) 114676: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 114679: 85 f6 test %esi,%esi <== NOT EXECUTED 11467b: 0f 84 a3 00 00 00 je 114724 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; seconds = _TOD_To_seconds( wall_time ); 114681: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114684: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 114687: e8 24 d6 ff ff call 111cb0 <_TOD_To_seconds> <== NOT EXECUTED 11468c: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( seconds <= _TOD_Seconds_since_epoch ) 11468e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114691: 3b 05 8c 5b 13 00 cmp 0x135b8c,%eax <== NOT EXECUTED 114697: 77 0f ja 1146a8 <== NOT EXECUTED _Watchdog_Insert_seconds( &the_timer->Ticker, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 114699: b8 14 00 00 00 mov $0x14,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11469e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1146a1: 5b pop %ebx <== NOT EXECUTED 1146a2: 5e pop %esi <== NOT EXECUTED 1146a3: 5f pop %edi <== NOT EXECUTED 1146a4: c9 leave <== NOT EXECUTED 1146a5: c3 ret <== NOT EXECUTED 1146a6: 66 90 xchg %ax,%ax <== 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 1146a8: 53 push %ebx <== NOT EXECUTED 1146a9: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 1146ac: 50 push %eax <== NOT EXECUTED 1146ad: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1146b0: 68 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 1146b5: e8 e2 24 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED 1146ba: 89 c6 mov %eax,%esi <== NOT EXECUTED seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch ) return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 1146bc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1146bf: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 1146c2: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1146c4: 75 52 jne 114718 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 1146c6: 8d 58 10 lea 0x10(%eax),%ebx <== NOT EXECUTED 1146c9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1146cc: 53 push %ebx <== NOT EXECUTED 1146cd: e8 06 41 00 00 call 1187d8 <_Watchdog_Remove> <== NOT EXECUTED the_timer->the_class = TIMER_TIME_OF_DAY; 1146d2: 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. * 1146d9: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 1146e0: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1146e3: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 1146e6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1146e9: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED * the heap 1146ec: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1146ef: 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, 1146f2: 2b 3d 8c 5b 13 00 sub 0x135b8c,%edi <== NOT EXECUTED 1146f8: 89 7e 1c mov %edi,0x1c(%esi) <== NOT EXECUTED size_t size ); 1146fb: 58 pop %eax <== NOT EXECUTED 1146fc: 5a pop %edx <== NOT EXECUTED 1146fd: 53 push %ebx <== NOT EXECUTED 1146fe: 68 d0 5b 13 00 push $0x135bd0 <== NOT EXECUTED 114703: e8 a0 3f 00 00 call 1186a8 <_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(); 114708: e8 d3 2c 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 11470d: 31 c0 xor %eax,%eax <== NOT EXECUTED 11470f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114712: e9 44 ff ff ff jmp 11465b <== NOT EXECUTED 114717: 90 nop <== NOT EXECUTED seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch ) return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 114718: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 11471d: e9 39 ff ff ff jmp 11465b <== NOT EXECUTED 114722: 66 90 xchg %ax,%ax <== NOT EXECUTED return RTEMS_NOT_DEFINED; if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; if ( !routine ) 114724: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 114729: e9 2d ff ff ff jmp 11465b <== NOT EXECUTED 00114730 : rtems_status_code rtems_timer_get_information( Objects_Id id, rtems_timer_information *the_info ) { 114730: 55 push %ebp <== NOT EXECUTED 114731: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114733: 53 push %ebx <== NOT EXECUTED 114734: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 114737: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 11473a: 85 db test %ebx,%ebx <== NOT EXECUTED 11473c: 74 4e je 11478c <== 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 11473e: 52 push %edx <== NOT EXECUTED 11473f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 114742: 50 push %eax <== NOT EXECUTED 114743: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114746: 68 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 11474b: e8 4c 24 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED 114750: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 114752: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114755: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 114758: 85 c0 test %eax,%eax <== NOT EXECUTED 11475a: 74 0c je 114768 <== NOT EXECUTED 11475c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114761: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114764: c9 leave <== NOT EXECUTED 114765: c3 ret <== NOT EXECUTED 114766: 66 90 xchg %ax,%ax <== NOT EXECUTED the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 114768: 8b 42 38 mov 0x38(%edx),%eax <== NOT EXECUTED 11476b: 89 03 mov %eax,(%ebx) <== NOT EXECUTED the_info->initial = the_timer->Ticker.initial; 11476d: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 114770: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED the_info->start_time = the_timer->Ticker.start_time; 114773: 8b 42 24 mov 0x24(%edx),%eax <== NOT EXECUTED 114776: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED the_info->stop_time = the_timer->Ticker.stop_time; 114779: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 11477c: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 11477f: e8 5c 2c 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 114784: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114786: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114789: c9 leave <== NOT EXECUTED 11478a: c3 ret <== NOT EXECUTED 11478b: 90 nop <== NOT EXECUTED ) { Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 11478c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114791: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114794: c9 leave <== NOT EXECUTED 114795: c3 ret <== NOT EXECUTED 00114798 : rtems_status_code rtems_timer_ident( rtems_name name, Objects_Id *id ) { 114798: 55 push %ebp <== NOT EXECUTED 114799: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11479b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 11479e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1147a1: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 1147a6: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1147a9: 68 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 1147ae: e8 41 25 00 00 call 116cf4 <_Objects_Name_to_id_u32> <== NOT EXECUTED 1147b3: 8b 04 85 8c a7 12 00 mov 0x12a78c(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 1147ba: c9 leave <== NOT EXECUTED 1147bb: c3 ret <== NOT EXECUTED 00114a40 : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 114a40: 55 push %ebp <== NOT EXECUTED 114a41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114a43: 56 push %esi <== NOT EXECUTED 114a44: 53 push %ebx <== NOT EXECUTED 114a45: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 114a48: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ); 114a4b: 85 d2 test %edx,%edx <== NOT EXECUTED 114a4d: 75 0d jne 114a5c <== 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; 114a4f: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED } return status; } 114a54: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 114a57: 5b pop %ebx <== NOT EXECUTED 114a58: 5e pop %esi <== NOT EXECUTED 114a59: c9 leave <== NOT EXECUTED 114a5a: c3 ret <== NOT EXECUTED 114a5b: 90 nop <== NOT EXECUTED 114a5c: 0f b6 05 d4 d1 12 00 movzbl 0x12d1d4,%eax <== NOT EXECUTED 114a63: 39 c2 cmp %eax,%edx <== NOT EXECUTED 114a65: 77 31 ja 114a98 <== NOT EXECUTED 114a67: 89 d6 mov %edx,%esi <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 114a69: a1 f8 5a 13 00 mov 0x135af8,%eax <== NOT EXECUTED 114a6e: 40 inc %eax <== NOT EXECUTED 114a6f: a3 f8 5a 13 00 mov %eax,0x135af8 <== NOT EXECUTED /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 114a74: 8a 1d c0 14 13 00 mov 0x1314c0,%bl <== NOT EXECUTED initialized = true; 114a7a: c6 05 c0 14 13 00 01 movb $0x1,0x1314c0 <== NOT EXECUTED _Thread_Enable_dispatch(); 114a81: e8 5a 29 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( tmpInitialized ) 114a86: 84 db test %bl,%bl <== NOT EXECUTED 114a88: 74 16 je 114aa0 <== NOT EXECUTED 114a8a: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED */ initialized = false; } return status; } 114a8f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 114a92: 5b pop %ebx <== NOT EXECUTED 114a93: 5e pop %esi <== NOT EXECUTED 114a94: c9 leave <== NOT EXECUTED 114a95: c3 ret <== NOT EXECUTED 114a96: 66 90 xchg %ax,%ax <== NOT EXECUTED * structured so we check it is invalid before looking for * a specific invalid value as the default. */ _priority = priority; if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) { if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 114a98: 42 inc %edx <== NOT EXECUTED 114a99: 75 b4 jne 114a4f <== NOT EXECUTED 114a9b: 31 f6 xor %esi,%esi <== NOT EXECUTED 114a9d: eb ca jmp 114a69 <== NOT EXECUTED 114a9f: 90 nop <== NOT EXECUTED 114aa0: c7 05 60 5a 13 00 64 movl $0x135a64,0x135a60 <== NOT EXECUTED 114aa7: 5a 13 00 <== NOT EXECUTED 114aaa: c7 05 64 5a 13 00 00 movl $0x0,0x135a64 <== NOT EXECUTED 114ab1: 00 00 00 <== NOT EXECUTED 114ab4: c7 05 68 5a 13 00 60 movl $0x135a60,0x135a68 <== NOT EXECUTED 114abb: 5a 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( 114abe: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114ac1: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 114ac4: 50 push %eax <== NOT EXECUTED 114ac5: 81 4d 10 00 80 00 00 orl $0x8000,0x10(%ebp) <== NOT EXECUTED 114acc: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 114acf: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 114ad4: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 114ad7: 56 push %esi <== NOT EXECUTED 114ad8: 68 45 4d 49 54 push $0x54494d45 <== NOT EXECUTED 114add: e8 fa f1 ff ff call 113cdc <== 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) { 114ae2: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 114ae5: 85 c0 test %eax,%eax <== NOT EXECUTED 114ae7: 0f 85 b2 00 00 00 jne 114b9f <== 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( 114aed: 8b 4d f4 mov -0xc(%ebp),%ecx <== NOT EXECUTED bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 114af0: 66 3b 0d 10 5a 13 00 cmp 0x135a10,%cx <== NOT EXECUTED 114af7: 0f 86 b3 00 00 00 jbe 114bb0 <== NOT EXECUTED 114afd: 31 c0 xor %eax,%eax <== NOT EXECUTED 114aff: a3 a4 5e 13 00 mov %eax,0x135ea4 <== NOT EXECUTED 114b04: c7 05 40 5a 13 00 44 movl $0x135a44,0x135a40 <== NOT EXECUTED 114b0b: 5a 13 00 <== NOT EXECUTED 114b0e: c7 05 44 5a 13 00 00 movl $0x0,0x135a44 <== NOT EXECUTED 114b15: 00 00 00 <== NOT EXECUTED 114b18: c7 05 48 5a 13 00 40 movl $0x135a40,0x135a48 <== NOT EXECUTED 114b1f: 5a 13 00 <== NOT EXECUTED 114b22: c7 05 54 5a 13 00 58 movl $0x135a58,0x135a54 <== NOT EXECUTED 114b29: 5a 13 00 <== NOT EXECUTED 114b2c: c7 05 58 5a 13 00 00 movl $0x0,0x135a58 <== NOT EXECUTED 114b33: 00 00 00 <== NOT EXECUTED 114b36: c7 05 5c 5a 13 00 54 movl $0x135a54,0x135a5c <== NOT EXECUTED 114b3d: 5a 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. * 114b40: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 114b47: c7 40 64 48 72 11 00 movl $0x117248,0x64(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 114b4e: 89 48 68 mov %ecx,0x68(%eax) <== NOT EXECUTED * the heap 114b51: 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. * 114b58: c7 05 88 5a 13 00 00 movl $0x0,0x135a88 <== NOT EXECUTED 114b5f: 00 00 00 <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 114b62: c7 05 9c 5a 13 00 48 movl $0x117248,0x135a9c <== NOT EXECUTED 114b69: 72 11 00 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 114b6c: 89 0d a0 5a 13 00 mov %ecx,0x135aa0 <== NOT EXECUTED * the heap 114b72: c7 05 a4 5a 13 00 00 movl $0x0,0x135aa4 <== NOT EXECUTED 114b79: 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; 114b7c: c7 05 a0 5e 13 00 c0 movl $0x114bc0,0x135ea0 <== NOT EXECUTED 114b83: 4b 11 00 <== NOT EXECUTED /* * Start the timer server */ status = rtems_task_start( 114b86: 50 push %eax <== NOT EXECUTED 114b87: 6a 00 push $0x0 <== NOT EXECUTED 114b89: 68 5c 4c 11 00 push $0x114c5c <== NOT EXECUTED 114b8e: 51 push %ecx <== NOT EXECUTED 114b8f: e8 5c f6 ff ff call 1141f0 <== 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) { 114b94: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114b97: 85 c0 test %eax,%eax <== NOT EXECUTED 114b99: 0f 84 b5 fe ff ff je 114a54 <== 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; 114b9f: c6 05 c0 14 13 00 00 movb $0x0,0x1314c0 <== NOT EXECUTED } return status; } 114ba6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 114ba9: 5b pop %ebx <== NOT EXECUTED 114baa: 5e pop %esi <== NOT EXECUTED 114bab: c9 leave <== NOT EXECUTED 114bac: c3 ret <== NOT EXECUTED 114bad: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 114bb0: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 114bb3: a1 1c 5a 13 00 mov 0x135a1c,%eax <== NOT EXECUTED 114bb8: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED 114bbb: e9 3f ff ff ff jmp 114aff <== NOT EXECUTED 001147bc : */ rtems_status_code rtems_timer_reset( Objects_Id id ) { 1147bc: 55 push %ebp <== NOT EXECUTED 1147bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1147bf: 53 push %ebx <== NOT EXECUTED 1147c0: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 1147c3: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1147c6: 50 push %eax <== NOT EXECUTED 1147c7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1147ca: 68 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 1147cf: e8 c8 23 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED 1147d4: 89 c3 mov %eax,%ebx <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 1147d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1147d9: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 1147dc: 85 c0 test %eax,%eax <== NOT EXECUTED 1147de: 74 0c je 1147ec <== NOT EXECUTED 1147e0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1147e5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1147e8: c9 leave <== NOT EXECUTED 1147e9: c3 ret <== NOT EXECUTED 1147ea: 66 90 xchg %ax,%ax <== NOT EXECUTED the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: switch ( the_timer->the_class ) { 1147ec: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 1147ef: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 1147f2: 74 40 je 114834 <== NOT EXECUTED 1147f4: 73 2a jae 114820 <== NOT EXECUTED case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); 1147f6: 83 c3 10 add $0x10,%ebx <== NOT EXECUTED 1147f9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1147fc: 53 push %ebx <== NOT EXECUTED 1147fd: e8 d6 3f 00 00 call 1187d8 <_Watchdog_Remove> <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); 114802: 5a pop %edx <== NOT EXECUTED 114803: 59 pop %ecx <== NOT EXECUTED 114804: 53 push %ebx <== NOT EXECUTED 114805: 68 dc 5b 13 00 push $0x135bdc <== NOT EXECUTED 11480a: e8 99 3e 00 00 call 1186a8 <_Watchdog_Insert> <== NOT EXECUTED 11480f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case TIMER_TIME_OF_DAY_ON_TASK: case TIMER_DORMANT: _Thread_Enable_dispatch(); return RTEMS_NOT_DEFINED; } _Thread_Enable_dispatch(); 114812: e8 c9 2b 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 114817: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114819: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11481c: c9 leave <== NOT EXECUTED 11481d: c3 ret <== NOT EXECUTED 11481e: 66 90 xchg %ax,%ax <== NOT EXECUTED the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: switch ( the_timer->the_class ) { 114820: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 114823: 77 ed ja 114812 <== NOT EXECUTED (*_Timer_Server_schedule_operation)( the_timer ); break; case TIMER_TIME_OF_DAY: case TIMER_TIME_OF_DAY_ON_TASK: case TIMER_DORMANT: _Thread_Enable_dispatch(); 114825: e8 b6 2b 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 11482a: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11482f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114832: c9 leave <== NOT EXECUTED 114833: c3 ret <== NOT EXECUTED case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); break; case TIMER_INTERVAL_ON_TASK: if ( !_Timer_Server_schedule_operation ) { 114834: a1 a0 5e 13 00 mov 0x135ea0,%eax <== NOT EXECUTED 114839: 85 c0 test %eax,%eax <== NOT EXECUTED 11483b: 74 1b je 114858 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } _Watchdog_Remove( &the_timer->Ticker ); 11483d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114840: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 114843: 50 push %eax <== NOT EXECUTED 114844: e8 8f 3f 00 00 call 1187d8 <_Watchdog_Remove> <== NOT EXECUTED (*_Timer_Server_schedule_operation)( the_timer ); 114849: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 11484c: ff 15 a0 5e 13 00 call *0x135ea0 <== NOT EXECUTED 114852: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114855: eb bb jmp 114812 <== NOT EXECUTED 114857: 90 nop <== NOT EXECUTED _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); break; case TIMER_INTERVAL_ON_TASK: if ( !_Timer_Server_schedule_operation ) { _Thread_Enable_dispatch(); 114858: e8 83 2b 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 11485d: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 114862: eb 81 jmp 1147e5 <== NOT EXECUTED 00114864 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 114864: 55 push %ebp <== NOT EXECUTED 114865: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114867: 53 push %ebx <== NOT EXECUTED 114868: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 11486b: a1 a4 5e 13 00 mov 0x135ea4,%eax <== NOT EXECUTED 114870: 85 c0 test %eax,%eax <== NOT EXECUTED 114872: 0f 84 b0 00 00 00 je 114928 <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !routine ) 114878: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 11487b: 85 c0 test %eax,%eax <== NOT EXECUTED 11487d: 0f 84 b1 00 00 00 je 114934 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 114883: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 114886: 85 c0 test %eax,%eax <== NOT EXECUTED 114888: 75 0a jne 114894 <== NOT EXECUTED 11488a: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11488f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114892: c9 leave <== NOT EXECUTED 114893: c3 ret <== NOT EXECUTED 114894: 53 push %ebx <== NOT EXECUTED 114895: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 114898: 50 push %eax <== NOT EXECUTED 114899: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11489c: 68 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 1148a1: e8 f6 22 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED 1148a6: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 1148a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1148ab: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 1148ae: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1148b0: 75 5a jne 11490c <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 1148b2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1148b5: 8d 40 10 lea 0x10(%eax),%eax <== NOT EXECUTED 1148b8: 50 push %eax <== NOT EXECUTED 1148b9: e8 1a 3f 00 00 call 1187d8 <_Watchdog_Remove> <== NOT EXECUTED _ISR_Disable( level ); 1148be: 9c pushf <== NOT EXECUTED 1148bf: fa cli <== NOT EXECUTED 1148c0: 58 pop %eax <== 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 ) { 1148c1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1148c4: 8b 53 18 mov 0x18(%ebx),%edx <== NOT EXECUTED 1148c7: 85 d2 test %edx,%edx <== NOT EXECUTED 1148c9: 75 4d jne 114918 <== 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; 1148cb: 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. * 1148d2: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 1148d9: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 1148dc: 89 53 2c mov %edx,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 1148df: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1148e2: 89 53 30 mov %edx,0x30(%ebx) <== NOT EXECUTED * the heap 1148e5: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 1148e8: 89 53 34 mov %edx,0x34(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = ticks; 1148eb: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 1148ee: 89 53 1c mov %edx,0x1c(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 1148f1: 50 push %eax <== NOT EXECUTED 1148f2: 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 ); 1148f3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1148f6: 53 push %ebx <== NOT EXECUTED 1148f7: ff 15 a0 5e 13 00 call *0x135ea0 <== NOT EXECUTED _Thread_Enable_dispatch(); 1148fd: e8 de 2a 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 114902: 31 c0 xor %eax,%eax <== NOT EXECUTED 114904: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114907: eb 86 jmp 11488f <== NOT EXECUTED 114909: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 11490c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114911: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114914: c9 leave <== NOT EXECUTED 114915: c3 ret <== NOT EXECUTED 114916: 66 90 xchg %ax,%ax <== 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 ) { _ISR_Enable( level ); 114918: 50 push %eax <== NOT EXECUTED 114919: 9d popf <== NOT EXECUTED _Thread_Enable_dispatch(); 11491a: e8 c1 2a 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 11491f: 31 c0 xor %eax,%eax <== NOT EXECUTED 114921: e9 69 ff ff ff jmp 11488f <== NOT EXECUTED 114926: 66 90 xchg %ax,%ax <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 114928: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 11492d: e9 5d ff ff ff jmp 11488f <== NOT EXECUTED 114932: 66 90 xchg %ax,%ax <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !routine ) 114934: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 114939: e9 51 ff ff ff jmp 11488f <== NOT EXECUTED 00114940 : Objects_Id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 114940: 55 push %ebp <== NOT EXECUTED 114941: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114943: 56 push %esi <== NOT EXECUTED 114944: 53 push %ebx <== NOT EXECUTED 114945: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_Timer_Server ) 114948: 8b 1d a4 5e 13 00 mov 0x135ea4,%ebx <== NOT EXECUTED 11494e: 85 db test %ebx,%ebx <== NOT EXECUTED 114950: 0f 84 d2 00 00 00 je 114a28 <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 114956: 80 3d 0c 5b 13 00 00 cmpb $0x0,0x135b0c <== NOT EXECUTED 11495d: 0f 84 ad 00 00 00 je 114a10 <== NOT EXECUTED return RTEMS_NOT_DEFINED; if ( !routine ) 114963: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 114966: 85 c9 test %ecx,%ecx <== NOT EXECUTED 114968: 0f 84 ae 00 00 00 je 114a1c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 11496e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114971: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 114974: e8 c7 d3 ff ff call 111d40 <_TOD_Validate> <== NOT EXECUTED 114979: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11497c: 84 c0 test %al,%al <== NOT EXECUTED 11497e: 75 0c jne 11498c <== NOT EXECUTED */ (*_Timer_Server_schedule_operation)( the_timer ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 114980: b8 14 00 00 00 mov $0x14,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114985: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 114988: 5b pop %ebx <== NOT EXECUTED 114989: 5e pop %esi <== NOT EXECUTED 11498a: c9 leave <== NOT EXECUTED 11498b: c3 ret <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 11498c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11498f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 114992: e8 19 d3 ff ff call 111cb0 <_TOD_To_seconds> <== NOT EXECUTED 114997: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( seconds <= _TOD_Seconds_since_epoch ) 114999: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11499c: 3b 05 8c 5b 13 00 cmp 0x135b8c,%eax <== NOT EXECUTED 1149a2: 76 dc jbe 114980 <== 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 1149a4: 52 push %edx <== NOT EXECUTED 1149a5: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1149a8: 50 push %eax <== NOT EXECUTED 1149a9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1149ac: 68 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 1149b1: e8 e6 21 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED 1149b6: 89 c3 mov %eax,%ebx <== NOT EXECUTED return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 1149b8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1149bb: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 1149be: 85 c0 test %eax,%eax <== NOT EXECUTED 1149c0: 75 72 jne 114a34 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 1149c2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1149c5: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 1149c8: 50 push %eax <== NOT EXECUTED 1149c9: e8 0a 3e 00 00 call 1187d8 <_Watchdog_Remove> <== NOT EXECUTED the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 1149ce: 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. * 1149d5: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 1149dc: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1149df: 89 43 2c mov %eax,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 1149e2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1149e5: 89 43 30 mov %eax,0x30(%ebx) <== NOT EXECUTED * the heap 1149e8: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1149eb: 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; 1149ee: 2b 35 8c 5b 13 00 sub 0x135b8c,%esi <== NOT EXECUTED 1149f4: 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 ); 1149f7: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 1149fa: ff 15 a0 5e 13 00 call *0x135ea0 <== NOT EXECUTED _Thread_Enable_dispatch(); 114a00: e8 db 29 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 114a05: 31 c0 xor %eax,%eax <== NOT EXECUTED 114a07: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114a0a: e9 76 ff ff ff jmp 114985 <== NOT EXECUTED 114a0f: 90 nop <== NOT EXECUTED rtems_interval seconds; if ( !_Timer_Server ) return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 114a10: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114a15: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 114a18: 5b pop %ebx <== NOT EXECUTED 114a19: 5e pop %esi <== NOT EXECUTED 114a1a: c9 leave <== NOT EXECUTED 114a1b: c3 ret <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) 114a1c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 114a21: e9 5f ff ff ff jmp 114985 <== NOT EXECUTED 114a26: 66 90 xchg %ax,%ax <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_Timer_Server ) 114a28: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 114a2d: e9 53 ff ff ff jmp 114985 <== NOT EXECUTED 114a32: 66 90 xchg %ax,%ax <== NOT EXECUTED seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch ) return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 114a34: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 114a39: e9 47 ff ff ff jmp 114985 <== NOT EXECUTED