0010ad0c <_API_Mutex_Allocate>: #include void _API_Mutex_Allocate( API_Mutex_Control **the_mutex ) { 10ad0c: 55 push %ebp <== NOT EXECUTED 10ad0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad0f: 57 push %edi <== NOT EXECUTED 10ad10: 56 push %esi <== NOT EXECUTED 10ad11: 53 push %ebx <== NOT EXECUTED 10ad12: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED CORE_mutex_Attributes attr = { CORE_MUTEX_NESTING_IS_ERROR, FALSE, CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT, 0 }; 10ad15: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 10ad18: be e8 90 11 00 mov $0x1190e8,%esi <== NOT EXECUTED 10ad1d: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10ad22: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED mutex = (API_Mutex_Control *) _Objects_Allocate( &_API_Mutex_Information ); 10ad24: 68 c0 f8 11 00 push $0x11f8c0 <== NOT EXECUTED 10ad29: e8 e6 08 00 00 call 10b614 <_Objects_Allocate> <== NOT EXECUTED 10ad2e: 89 c3 mov %eax,%ebx <== NOT EXECUTED _CORE_mutex_Initialize( &mutex->Mutex, &attr, CORE_MUTEX_UNLOCKED ); 10ad30: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ad33: 6a 01 push $0x1 <== NOT EXECUTED 10ad35: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10ad38: 50 push %eax <== NOT EXECUTED 10ad39: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10ad3c: 50 push %eax <== NOT EXECUTED 10ad3d: e8 22 02 00 00 call 10af64 <_CORE_mutex_Initialize> <== NOT EXECUTED 10ad42: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 10ad46: a1 dc f8 11 00 mov 0x11f8dc,%eax <== NOT EXECUTED 10ad4b: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10ad4e: 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; 10ad55: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ad58: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10ad5a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10ad5d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ad60: 5b pop %ebx <== NOT EXECUTED 10ad61: 5e pop %esi <== NOT EXECUTED 10ad62: 5f pop %edi <== NOT EXECUTED 10ad63: c9 leave <== NOT EXECUTED 10ad64: c3 ret <== NOT EXECUTED 0010ad8c <_API_Mutex_Initialization>: #include void _API_Mutex_Initialization( uint32_t maximum_mutexes ) { 10ad8c: 55 push %ebp <== NOT EXECUTED 10ad8d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad8f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ad92: 6a 00 push $0x0 <== NOT EXECUTED 10ad94: 6a 00 push $0x0 <== NOT EXECUTED 10ad96: 6a 74 push $0x74 <== NOT EXECUTED 10ad98: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ad9b: 6a 02 push $0x2 <== NOT EXECUTED 10ad9d: 6a 01 push $0x1 <== NOT EXECUTED 10ad9f: 68 c0 f8 11 00 push $0x11f8c0 <== NOT EXECUTED 10ada4: e8 c3 0d 00 00 call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10ada9: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , TRUE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10adac: c9 leave <== NOT EXECUTED 10adad: c3 ret <== NOT EXECUTED 0010ad68 <_API_Mutex_Lock>: #include void _API_Mutex_Lock( API_Mutex_Control *the_mutex ) { 10ad68: 55 push %ebp <== NOT EXECUTED 10ad69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad6b: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10ad6e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10ad71: 9c pushf <== NOT EXECUTED 10ad72: fa cli <== NOT EXECUTED 10ad73: 5a pop %edx <== NOT EXECUTED _CORE_mutex_Seize( 10ad74: 52 push %edx <== NOT EXECUTED 10ad75: 6a 00 push $0x0 <== NOT EXECUTED 10ad77: 6a 01 push $0x1 <== NOT EXECUTED 10ad79: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10ad7c: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10ad7f: 50 push %eax <== NOT EXECUTED 10ad80: e8 d7 02 00 00 call 10b05c <_CORE_mutex_Seize> <== NOT EXECUTED 10ad85: 83 c4 20 add $0x20,%esp <== NOT EXECUTED the_mutex->Object.id, TRUE, 0, level ); } 10ad88: c9 leave <== NOT EXECUTED 10ad89: c3 ret <== NOT EXECUTED 0010adb0 <_API_Mutex_Unlock>: #include void _API_Mutex_Unlock( API_Mutex_Control *the_mutex ) { 10adb0: 55 push %ebp <== NOT EXECUTED 10adb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10adb3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10adb6: 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 10adb9: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10adbe: 40 inc %eax <== NOT EXECUTED 10adbf: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED _Thread_Disable_dispatch(); _CORE_mutex_Surrender( 10adc4: 6a 00 push $0x0 <== NOT EXECUTED 10adc6: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED 10adc9: 83 c2 10 add $0x10,%edx <== NOT EXECUTED 10adcc: 52 push %edx <== NOT EXECUTED 10adcd: e8 26 03 00 00 call 10b0f8 <_CORE_mutex_Surrender> <== NOT EXECUTED &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 10add2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10add5: c9 leave <== NOT EXECUTED _CORE_mutex_Surrender( &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 10add6: e9 71 15 00 00 jmp 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED 0010acf4 <_API_extensions_Add>: */ void _API_extensions_Add( API_extensions_Control *the_extension ) { 10acf4: 55 push %ebp <== NOT EXECUTED 10acf5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10acf7: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED _Chain_Append( &_API_extensions_List, &the_extension->Node ); 10acfa: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10acfd: 68 18 fa 11 00 push $0x11fa18 <== NOT EXECUTED 10ad02: e8 d5 00 00 00 call 10addc <_Chain_Append> <== NOT EXECUTED 10ad07: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10ad0a: c9 leave <== NOT EXECUTED 10ad0b: c3 ret <== NOT EXECUTED 0010ac34 <_API_extensions_Initialization>: * * _API_extensions_Initialization */ void _API_extensions_Initialization( void ) { 10ac34: 55 push %ebp <== NOT EXECUTED 10ac35: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac37: c7 05 18 fa 11 00 1c movl $0x11fa1c,0x11fa18 <== NOT EXECUTED 10ac3e: fa 11 00 <== NOT EXECUTED 10ac41: c7 05 1c fa 11 00 00 movl $0x0,0x11fa1c <== NOT EXECUTED 10ac48: 00 00 00 <== NOT EXECUTED 10ac4b: c7 05 20 fa 11 00 18 movl $0x11fa18,0x11fa20 <== NOT EXECUTED 10ac52: fa 11 00 <== NOT EXECUTED _Chain_Initialize_empty( &_API_extensions_List ); } 10ac55: c9 leave <== NOT EXECUTED 10ac56: c3 ret <== NOT EXECUTED 0010ac88 <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 10ac88: 55 push %ebp <== NOT EXECUTED 10ac89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac8b: 53 push %ebx <== NOT EXECUTED 10ac8c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10ac8f: 8b 1d 18 fa 11 00 mov 0x11fa18,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10ac95: 81 fb 1c fa 11 00 cmp $0x11fa1c,%ebx <== NOT EXECUTED 10ac9b: 74 16 je 10acb3 <_API_extensions_Run_postdriver+0x2b> <== NOT EXECUTED 10ac9d: 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 ) 10aca0: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10aca3: 85 c0 test %eax,%eax <== NOT EXECUTED 10aca5: 74 02 je 10aca9 <_API_extensions_Run_postdriver+0x21> <== NOT EXECUTED (*the_extension->postdriver_hook)(); 10aca7: 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 ) { 10aca9: 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 ) ; 10acab: 81 fb 1c fa 11 00 cmp $0x11fa1c,%ebx <== NOT EXECUTED 10acb1: 75 ed jne 10aca0 <_API_extensions_Run_postdriver+0x18> <== NOT EXECUTED the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) (*the_extension->postdriver_hook)(); } } 10acb3: 5a pop %edx <== NOT EXECUTED 10acb4: 5b pop %ebx <== NOT EXECUTED 10acb5: c9 leave <== NOT EXECUTED 10acb6: c3 ret <== NOT EXECUTED 0010acb8 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 10acb8: 55 push %ebp <== NOT EXECUTED 10acb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10acbb: 53 push %ebx <== NOT EXECUTED 10acbc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10acbf: 8b 1d 18 fa 11 00 mov 0x11fa18,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10acc5: 81 fb 1c fa 11 00 cmp $0x11fa1c,%ebx <== NOT EXECUTED 10accb: 74 22 je 10acef <_API_extensions_Run_postswitch+0x37> <== NOT EXECUTED 10accd: 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 ) 10acd0: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10acd3: 85 c0 test %eax,%eax <== NOT EXECUTED 10acd5: 74 0e je 10ace5 <_API_extensions_Run_postswitch+0x2d> <== NOT EXECUTED (*the_extension->postswitch_hook)( _Thread_Executing ); 10acd7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10acda: ff 35 7c f8 11 00 pushl 0x11f87c <== NOT EXECUTED 10ace0: ff d0 call *%eax <== NOT EXECUTED 10ace2: 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 ) { 10ace5: 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 ) ; 10ace7: 81 fb 1c fa 11 00 cmp $0x11fa1c,%ebx <== NOT EXECUTED 10aced: 75 e1 jne 10acd0 <_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 ); } } 10acef: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10acf2: c9 leave <== NOT EXECUTED 10acf3: c3 ret <== NOT EXECUTED 0010ac58 <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 10ac58: 55 push %ebp <== NOT EXECUTED 10ac59: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac5b: 53 push %ebx <== NOT EXECUTED 10ac5c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10ac5f: 8b 1d 18 fa 11 00 mov 0x11fa18,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10ac65: 81 fb 1c fa 11 00 cmp $0x11fa1c,%ebx <== NOT EXECUTED 10ac6b: 74 16 je 10ac83 <_API_extensions_Run_predriver+0x2b> <== NOT EXECUTED 10ac6d: 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 ) 10ac70: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10ac73: 85 c0 test %eax,%eax <== NOT EXECUTED 10ac75: 74 02 je 10ac79 <_API_extensions_Run_predriver+0x21> <== NOT EXECUTED (*the_extension->predriver_hook)(); 10ac77: 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 ) { 10ac79: 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 ) ; 10ac7b: 81 fb 1c fa 11 00 cmp $0x11fa1c,%ebx <== NOT EXECUTED 10ac81: 75 ed jne 10ac70 <_API_extensions_Run_predriver+0x18> <== NOT EXECUTED the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) (*the_extension->predriver_hook)(); } } 10ac83: 58 pop %eax <== NOT EXECUTED 10ac84: 5b pop %ebx <== NOT EXECUTED 10ac85: c9 leave <== NOT EXECUTED 10ac86: c3 ret <== NOT EXECUTED 0010f290 <_Barrier_Manager_initialization>: */ void _Barrier_Manager_initialization( uint32_t maximum_barriers ) { 10f290: 55 push %ebp <== NOT EXECUTED 10f291: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f293: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f296: 6a 04 push $0x4 <== NOT EXECUTED 10f298: 6a 00 push $0x0 <== NOT EXECUTED 10f29a: 6a 60 push $0x60 <== NOT EXECUTED 10f29c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f29f: 6a 0a push $0xa <== NOT EXECUTED 10f2a1: 6a 02 push $0x2 <== NOT EXECUTED 10f2a3: 68 40 02 12 00 push $0x120240 <== NOT EXECUTED 10f2a8: e8 bf c8 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10f2ad: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10f2b0: c9 leave <== NOT EXECUTED 10f2b1: c3 ret <== NOT EXECUTED 001102cc <_Barrier_Translate_core_barrier_return_code>: }; rtems_status_code _Barrier_Translate_core_barrier_return_code ( CORE_barrier_Status the_barrier_status ) { 1102cc: 55 push %ebp <== NOT EXECUTED 1102cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1102cf: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1102d2: 8b 04 85 14 05 12 00 mov 0x120514(,%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]; } 1102d9: c9 leave <== NOT EXECUTED 1102da: c3 ret <== NOT EXECUTED 0010cd98 <_CORE_RWLock_Initialize>: void _CORE_RWLock_Initialize( CORE_RWLock_Control *the_rwlock, CORE_RWLock_Attributes *the_rwlock_attributes ) { 10cd98: 55 push %ebp <== NOT EXECUTED 10cd99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cd9b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10cd9e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED the_rwlock->Attributes = *the_rwlock_attributes; 10cda1: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10cda4: 8b 12 mov (%edx),%edx <== NOT EXECUTED 10cda6: 89 50 40 mov %edx,0x40(%eax) <== NOT EXECUTED /* the_rwlock->number_of_waiting_threads = 0; */ the_rwlock->number_of_readers = 0; 10cda9: c7 40 48 00 00 00 00 movl $0x0,0x48(%eax) <== NOT EXECUTED the_rwlock->current_state = CORE_RWLOCK_UNLOCKED; 10cdb0: c7 40 44 00 00 00 00 movl $0x0,0x44(%eax) <== NOT EXECUTED _Thread_queue_Initialize( 10cdb7: 6a 03 push $0x3 <== NOT EXECUTED 10cdb9: 68 00 00 02 00 push $0x20000 <== NOT EXECUTED 10cdbe: 6a 00 push $0x0 <== NOT EXECUTED 10cdc0: 50 push %eax <== NOT EXECUTED 10cdc1: e8 4a 1c 00 00 call 10ea10 <_Thread_queue_Initialize> <== NOT EXECUTED 10cdc6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &the_rwlock->Wait_queue, THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_RWLOCK, CORE_RWLOCK_TIMEOUT ); } 10cdc9: c9 leave <== NOT EXECUTED 10cdca: c3 ret <== NOT EXECUTED 0010cdcc <_CORE_RWLock_Obtain_for_reading>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_RWLock_API_mp_support_callout api_rwlock_mp_support ) { 10cdcc: 55 push %ebp <== NOT EXECUTED 10cdcd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cdcf: 57 push %edi <== NOT EXECUTED 10cdd0: 56 push %esi <== NOT EXECUTED 10cdd1: 53 push %ebx <== NOT EXECUTED 10cdd2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cdd5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10cdd8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10cddb: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 10cdde: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10cde1: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 10cde4: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 10cde7: 88 45 ef mov %al,-0x11(%ebp) <== NOT EXECUTED ISR_Level level; Thread_Control *executing = _Thread_Executing; 10cdea: 8b 35 dc 20 12 00 mov 0x1220dc,%esi <== NOT EXECUTED * If unlocked, then OK to read. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 10cdf0: 9c pushf <== NOT EXECUTED 10cdf1: fa cli <== NOT EXECUTED 10cdf2: 5f pop %edi <== NOT EXECUTED switch ( the_rwlock->current_state ) { 10cdf3: 8b 43 44 mov 0x44(%ebx),%eax <== NOT EXECUTED 10cdf6: 85 c0 test %eax,%eax <== NOT EXECUTED 10cdf8: 75 1e jne 10ce18 <_CORE_RWLock_Obtain_for_reading+0x4c> <== NOT EXECUTED case CORE_RWLOCK_UNLOCKED: the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10cdfa: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx) <== NOT EXECUTED the_rwlock->number_of_readers += 1; 10ce01: ff 43 48 incl 0x48(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10ce04: 57 push %edi <== NOT EXECUTED 10ce05: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10ce06: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) <== NOT EXECUTED timeout, _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10ce0d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ce10: 5b pop %ebx <== NOT EXECUTED 10ce11: 5e pop %esi <== NOT EXECUTED 10ce12: 5f pop %edi <== NOT EXECUTED 10ce13: c9 leave <== NOT EXECUTED 10ce14: c3 ret <== NOT EXECUTED 10ce15: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); switch ( the_rwlock->current_state ) { 10ce18: 48 dec %eax <== NOT EXECUTED 10ce19: 74 55 je 10ce70 <_CORE_RWLock_Obtain_for_reading+0xa4> <== NOT EXECUTED /* * If the thread is not willing to wait, then return immediately. */ if ( !wait ) { 10ce1b: 80 7d ef 00 cmpb $0x0,-0x11(%ebp) <== NOT EXECUTED 10ce1f: 75 13 jne 10ce34 <_CORE_RWLock_Obtain_for_reading+0x68> <== NOT EXECUTED _ISR_Enable( level ); 10ce21: 57 push %edi <== NOT EXECUTED 10ce22: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10ce23: c7 46 34 02 00 00 00 movl $0x2,0x34(%esi) <== NOT EXECUTED timeout, _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10ce2a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ce2d: 5b pop %ebx <== NOT EXECUTED 10ce2e: 5e pop %esi <== NOT EXECUTED 10ce2f: 5f pop %edi <== NOT EXECUTED 10ce30: c9 leave <== NOT EXECUTED 10ce31: c3 ret <== NOT EXECUTED 10ce32: 66 90 xchg %ax,%ax <== 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 10ce34: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) <== NOT EXECUTED /* * We need to wait to enter this critical section */ _Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue ); executing->Wait.queue = &the_rwlock->Wait_queue; 10ce3b: 89 5e 44 mov %ebx,0x44(%esi) <== NOT EXECUTED executing->Wait.id = id; 10ce3e: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10ce41: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ; 10ce44: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi) <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10ce4b: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) <== NOT EXECUTED _ISR_Enable( level ); 10ce52: 57 push %edi <== NOT EXECUTED 10ce53: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue_with_handler( 10ce54: c7 45 10 c8 cf 10 00 movl $0x10cfc8,0x10(%ebp) <== NOT EXECUTED 10ce5b: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10ce5e: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10ce61: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED timeout, _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10ce64: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ce67: 5b pop %ebx <== NOT EXECUTED 10ce68: 5e pop %esi <== NOT EXECUTED 10ce69: 5f pop %edi <== NOT EXECUTED 10ce6a: c9 leave <== NOT EXECUTED executing->Wait.id = id; executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ; executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; _ISR_Enable( level ); _Thread_queue_Enqueue_with_handler( 10ce6b: e9 e0 17 00 00 jmp 10e650 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; return; case CORE_RWLOCK_LOCKED_FOR_READING: { Thread_Control *waiter; waiter = _Thread_queue_First( &the_rwlock->Wait_queue ); 10ce70: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ce73: 53 push %ebx <== NOT EXECUTED 10ce74: e8 13 1b 00 00 call 10e98c <_Thread_queue_First> <== NOT EXECUTED if ( !waiter ) { 10ce79: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ce7c: 85 c0 test %eax,%eax <== NOT EXECUTED 10ce7e: 75 9b jne 10ce1b <_CORE_RWLock_Obtain_for_reading+0x4f> <== NOT EXECUTED the_rwlock->number_of_readers += 1; 10ce80: ff 43 48 incl 0x48(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10ce83: 57 push %edi <== NOT EXECUTED 10ce84: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10ce85: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) <== NOT EXECUTED 10ce8c: e9 7c ff ff ff jmp 10ce0d <_CORE_RWLock_Obtain_for_reading+0x41> <== NOT EXECUTED 0010ce94 <_CORE_RWLock_Obtain_for_writing>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_RWLock_API_mp_support_callout api_rwlock_mp_support ) { 10ce94: 55 push %ebp <== NOT EXECUTED 10ce95: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ce97: 57 push %edi <== NOT EXECUTED 10ce98: 56 push %esi <== NOT EXECUTED 10ce99: 53 push %ebx <== NOT EXECUTED 10ce9a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ce9d: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10cea0: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 10cea3: 8a 5d 10 mov 0x10(%ebp),%bl <== NOT EXECUTED ISR_Level level; Thread_Control *executing = _Thread_Executing; 10cea6: 8b 15 dc 20 12 00 mov 0x1220dc,%edx <== NOT EXECUTED * Otherwise, we have to block. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 10ceac: 9c pushf <== NOT EXECUTED 10cead: fa cli <== NOT EXECUTED 10ceae: 59 pop %ecx <== NOT EXECUTED switch ( the_rwlock->current_state ) { 10ceaf: 83 78 44 00 cmpl $0x0,0x44(%eax) <== NOT EXECUTED 10ceb3: 75 17 jne 10cecc <_CORE_RWLock_Obtain_for_writing+0x38> <== NOT EXECUTED case CORE_RWLOCK_UNLOCKED: the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10ceb5: c7 40 44 02 00 00 00 movl $0x2,0x44(%eax) <== NOT EXECUTED _ISR_Enable( level ); 10cebc: 51 push %ecx <== NOT EXECUTED 10cebd: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10cebe: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10cec5: 5b pop %ebx <== NOT EXECUTED 10cec6: 5e pop %esi <== NOT EXECUTED 10cec7: 5f pop %edi <== NOT EXECUTED 10cec8: c9 leave <== NOT EXECUTED 10cec9: c3 ret <== NOT EXECUTED 10ceca: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * If the thread is not willing to wait, then return immediately. */ if ( !wait ) { 10cecc: 84 db test %bl,%bl <== NOT EXECUTED 10cece: 75 10 jne 10cee0 <_CORE_RWLock_Obtain_for_writing+0x4c> <== NOT EXECUTED _ISR_Enable( level ); 10ced0: 51 push %ecx <== NOT EXECUTED 10ced1: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10ced2: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) <== NOT EXECUTED _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10ced9: 5b pop %ebx <== NOT EXECUTED 10ceda: 5e pop %esi <== NOT EXECUTED 10cedb: 5f pop %edi <== NOT EXECUTED 10cedc: c9 leave <== NOT EXECUTED 10cedd: c3 ret <== NOT EXECUTED 10cede: 66 90 xchg %ax,%ax <== NOT EXECUTED 10cee0: c7 40 30 01 00 00 00 movl $0x1,0x30(%eax) <== NOT EXECUTED /* * We need to wait to enter this critical section */ _Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue ); executing->Wait.queue = &the_rwlock->Wait_queue; 10cee7: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED executing->Wait.id = id; 10ceea: 89 72 20 mov %esi,0x20(%edx) <== NOT EXECUTED executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE; 10ceed: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx) <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10cef4: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED _ISR_Enable( level ); 10cefb: 51 push %ecx <== NOT EXECUTED 10cefc: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue_with_handler( 10cefd: c7 45 10 c8 cf 10 00 movl $0x10cfc8,0x10(%ebp) <== NOT EXECUTED 10cf04: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED 10cf07: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10cf0a: 5b pop %ebx <== NOT EXECUTED 10cf0b: 5e pop %esi <== NOT EXECUTED 10cf0c: 5f pop %edi <== NOT EXECUTED 10cf0d: c9 leave <== NOT EXECUTED executing->Wait.id = id; executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE; executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; _ISR_Enable( level ); _Thread_queue_Enqueue_with_handler( 10cf0e: e9 3d 17 00 00 jmp 10e650 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 0010cf14 <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 10cf14: 55 push %ebp <== NOT EXECUTED 10cf15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cf17: 53 push %ebx <== NOT EXECUTED 10cf18: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10cf1b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; Thread_Control *executing = _Thread_Executing; 10cf1e: 8b 0d dc 20 12 00 mov 0x1220dc,%ecx <== NOT EXECUTED * Otherwise, we have to block. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 10cf24: 9c pushf <== NOT EXECUTED 10cf25: fa cli <== NOT EXECUTED 10cf26: 5a pop %edx <== NOT EXECUTED if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ 10cf27: 8b 43 44 mov 0x44(%ebx),%eax <== NOT EXECUTED 10cf2a: 85 c0 test %eax,%eax <== NOT EXECUTED 10cf2c: 74 7a je 10cfa8 <_CORE_RWLock_Release+0x94> <== NOT EXECUTED _ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; return CORE_RWLOCK_SUCCESSFUL; } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { 10cf2e: 48 dec %eax <== NOT EXECUTED 10cf2f: 74 63 je 10cf94 <_CORE_RWLock_Release+0x80> <== NOT EXECUTED return CORE_RWLOCK_SUCCESSFUL; } } /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */ executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10cf31: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) <== NOT EXECUTED /* * Implicitly transition to "unlocked" and find another thread interested * in obtaining this rwlock. */ the_rwlock->current_state = CORE_RWLOCK_UNLOCKED; 10cf38: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10cf3f: 52 push %edx <== NOT EXECUTED 10cf40: 9d popf <== NOT EXECUTED next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 10cf41: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cf44: 53 push %ebx <== NOT EXECUTED 10cf45: e8 ca 15 00 00 call 10e514 <_Thread_queue_Dequeue> <== NOT EXECUTED if ( next ) { 10cf4a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cf4d: 85 c0 test %eax,%eax <== NOT EXECUTED 10cf4f: 74 39 je 10cf8a <_CORE_RWLock_Release+0x76> <== NOT EXECUTED if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 10cf51: 83 78 30 01 cmpl $0x1,0x30(%eax) <== NOT EXECUTED 10cf55: 74 61 je 10cfb8 <_CORE_RWLock_Release+0xa4> <== NOT EXECUTED } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 10cf57: ff 43 48 incl 0x48(%ebx) <== NOT EXECUTED the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10cf5a: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx) <== NOT EXECUTED 10cf61: eb 17 jmp 10cf7a <_CORE_RWLock_Release+0x66> <== NOT EXECUTED 10cf63: 90 nop <== NOT EXECUTED /* * Now see if more readers can be let go. */ while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); if ( !next || 10cf64: 83 78 30 01 cmpl $0x1,0x30(%eax) <== NOT EXECUTED 10cf68: 74 20 je 10cf8a <_CORE_RWLock_Release+0x76> <== NOT EXECUTED next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) return CORE_RWLOCK_SUCCESSFUL; the_rwlock->number_of_readers += 1; 10cf6a: ff 43 48 incl 0x48(%ebx) <== NOT EXECUTED _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 10cf6d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10cf70: 50 push %eax <== NOT EXECUTED 10cf71: 53 push %ebx <== NOT EXECUTED 10cf72: e8 f5 18 00 00 call 10e86c <_Thread_queue_Extract> <== NOT EXECUTED 10cf77: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Now see if more readers can be let go. */ while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); 10cf7a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cf7d: 53 push %ebx <== NOT EXECUTED 10cf7e: e8 09 1a 00 00 call 10e98c <_Thread_queue_First> <== NOT EXECUTED if ( !next || 10cf83: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cf86: 85 c0 test %eax,%eax <== NOT EXECUTED 10cf88: 75 da jne 10cf64 <_CORE_RWLock_Release+0x50> <== NOT EXECUTED } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10cf8a: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cf8c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cf8f: c9 leave <== NOT EXECUTED 10cf90: c3 ret <== NOT EXECUTED 10cf91: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; return CORE_RWLOCK_SUCCESSFUL; } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { the_rwlock->number_of_readers -= 1; 10cf94: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10cf97: 48 dec %eax <== NOT EXECUTED 10cf98: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED if ( the_rwlock->number_of_readers != 0 ) { 10cf9b: 85 c0 test %eax,%eax <== NOT EXECUTED 10cf9d: 74 92 je 10cf31 <_CORE_RWLock_Release+0x1d> <== NOT EXECUTED /* must be unlocked again */ _ISR_Enable( level ); 10cf9f: 52 push %edx <== NOT EXECUTED 10cfa0: 9d popf <== NOT EXECUTED } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10cfa1: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cfa3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cfa6: c9 leave <== NOT EXECUTED 10cfa7: c3 ret <== NOT EXECUTED * If any thread is waiting, then we wait. */ _ISR_Disable( level ); if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ _ISR_Enable( level ); 10cfa8: 52 push %edx <== NOT EXECUTED 10cfa9: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10cfaa: c7 41 34 02 00 00 00 movl $0x2,0x34(%ecx) <== NOT EXECUTED } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10cfb1: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cfb3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cfb6: c9 leave <== NOT EXECUTED 10cfb7: c3 ret <== NOT EXECUTED next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); if ( next ) { if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10cfb8: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx) <== NOT EXECUTED } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10cfbf: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cfc1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cfc4: c9 leave <== NOT EXECUTED 10cfc5: c3 ret <== NOT EXECUTED 0010cfc8 <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 10cfc8: 55 push %ebp <== NOT EXECUTED 10cfc9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cfcb: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10cfce: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10cfd1: 50 push %eax <== NOT EXECUTED 10cfd2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cfd5: e8 da 11 00 00 call 10e1b4 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10cfda: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cfdd: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10cfe0: 85 d2 test %edx,%edx <== NOT EXECUTED 10cfe2: 75 17 jne 10cffb <_CORE_RWLock_Timeout+0x33> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10cfe4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cfe7: 50 push %eax <== NOT EXECUTED 10cfe8: e8 a3 1a 00 00 call 10ea90 <_Thread_queue_Process_timeout> <== NOT EXECUTED 10cfed: a1 18 20 12 00 mov 0x122018,%eax <== NOT EXECUTED 10cff2: 48 dec %eax <== NOT EXECUTED 10cff3: a3 18 20 12 00 mov %eax,0x122018 <== NOT EXECUTED 10cff8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Unnest_dispatch(); break; } } 10cffb: c9 leave <== NOT EXECUTED 10cffc: c3 ret <== NOT EXECUTED 0010bf30 <_CORE_barrier_Initialize>: void _CORE_barrier_Initialize( CORE_barrier_Control *the_barrier, CORE_barrier_Attributes *the_barrier_attributes ) { 10bf30: 55 push %ebp <== NOT EXECUTED 10bf31: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bf33: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bf36: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bf39: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED the_barrier->Attributes = *the_barrier_attributes; 10bf3c: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10bf3e: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10bf41: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED 10bf44: 89 4a 40 mov %ecx,0x40(%edx) <== NOT EXECUTED the_barrier->number_of_waiting_threads = 0; 10bf47: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) <== NOT EXECUTED _Thread_queue_Initialize( 10bf4e: 6a 03 push $0x3 <== NOT EXECUTED 10bf50: 68 00 00 01 00 push $0x10000 <== NOT EXECUTED 10bf55: 6a 00 push $0x0 <== NOT EXECUTED 10bf57: 52 push %edx <== NOT EXECUTED 10bf58: e8 e3 1c 00 00 call 10dc40 <_Thread_queue_Initialize> <== NOT EXECUTED 10bf5d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &the_barrier->Wait_queue, THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_BARRIER, CORE_BARRIER_TIMEOUT ); } 10bf60: c9 leave <== NOT EXECUTED 10bf61: c3 ret <== NOT EXECUTED 00110934 <_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 ) { 110934: 55 push %ebp <== NOT EXECUTED 110935: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110937: 56 push %esi <== NOT EXECUTED 110938: 53 push %ebx <== NOT EXECUTED 110939: 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)) ) { 11093c: 31 db xor %ebx,%ebx <== NOT EXECUTED 11093e: eb 01 jmp 110941 <_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++; 110940: 43 inc %ebx <== NOT EXECUTED { Thread_Control *the_thread; uint32_t count; count = 0; while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) { 110941: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110944: 56 push %esi <== NOT EXECUTED 110945: e8 46 cf ff ff call 10d890 <_Thread_queue_Dequeue> <== NOT EXECUTED 11094a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11094d: 85 c0 test %eax,%eax <== NOT EXECUTED 11094f: 75 ef jne 110940 <_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; 110951: c7 46 48 00 00 00 00 movl $0x0,0x48(%esi) <== NOT EXECUTED return count; } 110958: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11095a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11095d: 5b pop %ebx <== NOT EXECUTED 11095e: 5e pop %esi <== NOT EXECUTED 11095f: c9 leave <== NOT EXECUTED 110960: c3 ret <== NOT EXECUTED 0010bf64 <_CORE_barrier_Wait>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 10bf64: 55 push %ebp <== NOT EXECUTED 10bf65: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bf67: 57 push %edi <== NOT EXECUTED 10bf68: 56 push %esi <== NOT EXECUTED 10bf69: 53 push %ebx <== NOT EXECUTED 10bf6a: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bf6d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bf70: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10bf73: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 10bf76: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10bf79: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 10bf7c: 8b 0d dc 0f 12 00 mov 0x120fdc,%ecx <== NOT EXECUTED executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; 10bf82: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) <== NOT EXECUTED _ISR_Disable( level ); 10bf89: 9c pushf <== NOT EXECUTED 10bf8a: fa cli <== NOT EXECUTED 10bf8b: 5b pop %ebx <== NOT EXECUTED the_barrier->number_of_waiting_threads++; 10bf8c: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED 10bf8f: 40 inc %eax <== NOT EXECUTED 10bf90: 89 42 48 mov %eax,0x48(%edx) <== NOT EXECUTED if ( the_barrier->number_of_waiting_threads == 10bf93: 3b 42 44 cmp 0x44(%edx),%eax <== NOT EXECUTED 10bf96: 75 07 jne 10bf9f <_CORE_barrier_Wait+0x3b> <== NOT EXECUTED the_barrier->Attributes.maximum_count) { if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { 10bf98: 8b 42 40 mov 0x40(%edx),%eax <== NOT EXECUTED 10bf9b: 85 c0 test %eax,%eax <== NOT EXECUTED 10bf9d: 74 29 je 10bfc8 <_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 10bf9f: 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; 10bfa6: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED executing->Wait.id = id; 10bfa9: 89 79 20 mov %edi,0x20(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10bfac: 53 push %ebx <== NOT EXECUTED 10bfad: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); 10bfae: c7 45 10 1c dd 10 00 movl $0x10dd1c,0x10(%ebp) <== NOT EXECUTED 10bfb5: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10bfb8: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10bfbb: 58 pop %eax <== NOT EXECUTED 10bfbc: 5b pop %ebx <== NOT EXECUTED 10bfbd: 5e pop %esi <== NOT EXECUTED 10bfbe: 5f pop %edi <== NOT EXECUTED 10bfbf: 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 ); 10bfc0: e9 07 1a 00 00 jmp 10d9cc <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 10bfc5: 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; 10bfc8: c7 41 34 01 00 00 00 movl $0x1,0x34(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10bfcf: 53 push %ebx <== NOT EXECUTED 10bfd0: 9d popf <== NOT EXECUTED _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support ); 10bfd1: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10bfd4: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 10bfd7: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED 10bfda: 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 ); } 10bfdd: 5a pop %edx <== NOT EXECUTED 10bfde: 5b pop %ebx <== NOT EXECUTED 10bfdf: 5e pop %esi <== NOT EXECUTED 10bfe0: 5f pop %edi <== NOT EXECUTED 10bfe1: 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 ); 10bfe2: e9 4d 49 00 00 jmp 110934 <_CORE_barrier_Release> <== NOT EXECUTED 0011559c <_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 ) { 11559c: 55 push %ebp <== NOT EXECUTED 11559d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11559f: 57 push %edi <== NOT EXECUTED 1155a0: 56 push %esi <== NOT EXECUTED 1155a1: 53 push %ebx <== NOT EXECUTED 1155a2: 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 ) { 1155a5: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 1155a8: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1155ab: 39 50 4c cmp %edx,0x4c(%eax) <== NOT EXECUTED 1155ae: 72 58 jb 115608 <_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 ) { 1155b0: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 1155b3: 8b 46 48 mov 0x48(%esi),%eax <== NOT EXECUTED 1155b6: 85 c0 test %eax,%eax <== NOT EXECUTED 1155b8: 75 3a jne 1155f4 <_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))) { 1155ba: 31 db xor %ebx,%ebx <== NOT EXECUTED 1155bc: eb 16 jmp 1155d4 <_CORE_message_queue_Broadcast+0x38> <== NOT EXECUTED 1155be: 66 90 xchg %ax,%ax <== NOT EXECUTED waitp = &the_thread->Wait; number_broadcasted += 1; 1155c0: 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 1155c1: 8b 78 2c mov 0x2c(%eax),%edi <== NOT EXECUTED 1155c4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1155c7: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 1155ca: 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; 1155cc: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 1155cf: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 1155d2: 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))) { 1155d4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1155d7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1155da: e8 29 22 00 00 call 117808 <_Thread_queue_Dequeue> <== NOT EXECUTED 1155df: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1155e2: 85 c0 test %eax,%eax <== NOT EXECUTED 1155e4: 75 da jne 1155c0 <_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; 1155e6: 8b 75 1c mov 0x1c(%ebp),%esi <== NOT EXECUTED 1155e9: 89 1e mov %ebx,(%esi) <== NOT EXECUTED return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 1155eb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1155ee: 5b pop %ebx <== NOT EXECUTED 1155ef: 5e pop %esi <== NOT EXECUTED 1155f0: 5f pop %edi <== NOT EXECUTED 1155f1: c9 leave <== NOT EXECUTED 1155f2: c3 ret <== NOT EXECUTED 1155f3: 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; 1155f4: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 1155f7: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 1155fd: 31 c0 xor %eax,%eax <== NOT EXECUTED #endif } *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 1155ff: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 115602: 5b pop %ebx <== NOT EXECUTED 115603: 5e pop %esi <== NOT EXECUTED 115604: 5f pop %edi <== NOT EXECUTED 115605: c9 leave <== NOT EXECUTED 115606: c3 ret <== NOT EXECUTED 115607: 90 nop <== NOT EXECUTED { Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 115608: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED #endif } *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 11560d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 115610: 5b pop %ebx <== NOT EXECUTED 115611: 5e pop %esi <== NOT EXECUTED 115612: 5f pop %edi <== NOT EXECUTED 115613: c9 leave <== NOT EXECUTED 115614: c3 ret <== NOT EXECUTED 001164c8 <_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 ) { 1164c8: 55 push %ebp <== NOT EXECUTED 1164c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1164cb: 53 push %ebx <== NOT EXECUTED 1164cc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1164cf: 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( 1164d2: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1164d5: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1164d8: 53 push %ebx <== NOT EXECUTED 1164d9: e8 ae b3 ff ff call 11188c <_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 ) 1164de: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1164e1: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 1164e4: 85 c0 test %eax,%eax <== NOT EXECUTED 1164e6: 74 0c je 1164f4 <_CORE_message_queue_Close+0x2c> <== NOT EXECUTED (void) _CORE_message_queue_Flush_support( the_message_queue ); 1164e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1164eb: 53 push %ebx <== NOT EXECUTED 1164ec: e8 13 00 00 00 call 116504 <_CORE_message_queue_Flush_support> <== NOT EXECUTED 1164f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (void) _Workspace_Free( the_message_queue->message_buffers ); 1164f4: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED 1164f7: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 1164fa: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1164fd: 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 ); 1164fe: e9 2d be ff ff jmp 112330 <_Workspace_Free> <== NOT EXECUTED 00115654 <_CORE_message_queue_Flush>: */ uint32_t _CORE_message_queue_Flush( CORE_message_queue_Control *the_message_queue ) { 115654: 55 push %ebp <== NOT EXECUTED 115655: 89 e5 mov %esp,%ebp <== NOT EXECUTED 115657: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages != 0 ) 11565a: 8b 50 48 mov 0x48(%eax),%edx <== NOT EXECUTED 11565d: 85 d2 test %edx,%edx <== NOT EXECUTED 11565f: 75 07 jne 115668 <_CORE_message_queue_Flush+0x14> <== NOT EXECUTED return _CORE_message_queue_Flush_support( the_message_queue ); else return 0; } 115661: 31 c0 xor %eax,%eax <== NOT EXECUTED 115663: c9 leave <== NOT EXECUTED 115664: c3 ret <== NOT EXECUTED 115665: 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 ); 115668: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED else return 0; } 11566b: 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 ); 11566c: e9 03 00 00 00 jmp 115674 <_CORE_message_queue_Flush_support> <== NOT EXECUTED 00116504 <_CORE_message_queue_Flush_support>: */ uint32_t _CORE_message_queue_Flush_support( CORE_message_queue_Control *the_message_queue ) { 116504: 55 push %ebp <== NOT EXECUTED 116505: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116507: 56 push %esi <== NOT EXECUTED 116508: 53 push %ebx <== NOT EXECUTED 116509: 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 ); 11650c: 9c pushf <== NOT EXECUTED 11650d: fa cli <== NOT EXECUTED 11650e: 5e pop %esi <== NOT EXECUTED inactive_first = the_message_queue->Inactive_messages.first; 11650f: 8b 4a 68 mov 0x68(%edx),%ecx <== NOT EXECUTED message_queue_first = the_message_queue->Pending_messages.first; 116512: 8b 5a 50 mov 0x50(%edx),%ebx <== NOT EXECUTED message_queue_last = the_message_queue->Pending_messages.last; 116515: 8b 42 58 mov 0x58(%edx),%eax <== NOT EXECUTED the_message_queue->Inactive_messages.first = message_queue_first; 116518: 89 5a 68 mov %ebx,0x68(%edx) <== NOT EXECUTED message_queue_last->next = inactive_first; 11651b: 89 08 mov %ecx,(%eax) <== NOT EXECUTED inactive_first->previous = message_queue_last; 11651d: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED message_queue_first->previous = 116520: 8d 42 68 lea 0x68(%edx),%eax <== NOT EXECUTED 116523: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED 116526: 8d 42 54 lea 0x54(%edx),%eax <== NOT EXECUTED 116529: 89 42 50 mov %eax,0x50(%edx) <== NOT EXECUTED 11652c: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) <== NOT EXECUTED 116533: 8d 42 50 lea 0x50(%edx),%eax <== NOT EXECUTED 116536: 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; 116539: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED the_message_queue->number_of_pending_messages = 0; 11653c: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) <== NOT EXECUTED _ISR_Enable( level ); 116543: 56 push %esi <== NOT EXECUTED 116544: 9d popf <== NOT EXECUTED return count; } 116545: 5b pop %ebx <== NOT EXECUTED 116546: 5e pop %esi <== NOT EXECUTED 116547: c9 leave <== NOT EXECUTED 116548: c3 ret <== NOT EXECUTED 0010fe64 <_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 ) { 10fe64: 55 push %ebp <== NOT EXECUTED 10fe65: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fe67: 57 push %edi <== NOT EXECUTED 10fe68: 56 push %esi <== NOT EXECUTED 10fe69: 53 push %ebx <== NOT EXECUTED 10fe6a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fe6d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10fe70: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10fe73: 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; 10fe76: 89 7b 44 mov %edi,0x44(%ebx) <== NOT EXECUTED the_message_queue->number_of_pending_messages = 0; 10fe79: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) <== NOT EXECUTED the_message_queue->maximum_message_size = maximum_message_size; 10fe80: 89 53 4c mov %edx,0x4c(%ebx) <== NOT EXECUTED 10fe83: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED 10fe8a: 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)) { 10fe91: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 10fe94: 75 1a jne 10feb0 <_CORE_message_queue_Initialize+0x4c> <== NOT EXECUTED 10fe96: 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 * 10fe98: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 10fe9b: 89 f2 mov %esi,%edx <== NOT EXECUTED 10fe9d: 0f af d7 imul %edi,%edx <== NOT EXECUTED (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 10fea0: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10fea2: 73 18 jae 10febc <_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; 10fea4: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10fea6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fea9: 5b pop %ebx <== NOT EXECUTED 10feaa: 5e pop %esi <== NOT EXECUTED 10feab: 5f pop %edi <== NOT EXECUTED 10feac: c9 leave <== NOT EXECUTED 10fead: c3 ret <== NOT EXECUTED 10feae: 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); 10feb0: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED allocated_message_size &= ~(sizeof(uint32_t) - 1); 10feb3: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED } if (allocated_message_size < maximum_message_size) 10feb6: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10feb8: 77 ea ja 10fea4 <_CORE_message_queue_Initialize+0x40> <== NOT EXECUTED 10feba: eb dc jmp 10fe98 <_CORE_message_queue_Initialize+0x34> <== NOT EXECUTED return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 10febc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10febf: 52 push %edx <== NOT EXECUTED 10fec0: e8 e7 29 00 00 call 1128ac <_Workspace_Allocate> <== NOT EXECUTED 10fec5: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 10fec8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fecb: 85 c0 test %eax,%eax <== NOT EXECUTED 10fecd: 74 d5 je 10fea4 <_CORE_message_queue_Initialize+0x40> <== NOT EXECUTED /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 10fecf: 56 push %esi <== NOT EXECUTED 10fed0: 57 push %edi <== NOT EXECUTED 10fed1: 50 push %eax <== NOT EXECUTED 10fed2: 8d 43 68 lea 0x68(%ebx),%eax <== NOT EXECUTED 10fed5: 50 push %eax <== NOT EXECUTED 10fed6: e8 8d 6c 01 00 call 126b68 <_Chain_Initialize> <== NOT EXECUTED 10fedb: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10fede: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED 10fee1: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED 10fee8: 8d 43 50 lea 0x50(%ebx),%eax <== NOT EXECUTED 10feeb: 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( 10feee: 6a 06 push $0x6 <== NOT EXECUTED 10fef0: 68 80 00 00 00 push $0x80 <== NOT EXECUTED 10fef5: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10fef8: 83 38 01 cmpl $0x1,(%eax) <== NOT EXECUTED 10fefb: 0f 94 c0 sete %al <== NOT EXECUTED 10fefe: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10ff01: 50 push %eax <== NOT EXECUTED 10ff02: 53 push %ebx <== NOT EXECUTED 10ff03: e8 a4 1f 00 00 call 111eac <_Thread_queue_Initialize> <== NOT EXECUTED 10ff08: b0 01 mov $0x1,%al <== NOT EXECUTED 10ff0a: 83 c4 20 add $0x20,%esp <== NOT EXECUTED STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; } 10ff0d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ff10: 5b pop %ebx <== NOT EXECUTED 10ff11: 5e pop %esi <== NOT EXECUTED 10ff12: 5f pop %edi <== NOT EXECUTED 10ff13: c9 leave <== NOT EXECUTED 10ff14: c3 ret <== NOT EXECUTED 0010f71c <_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 ) { 10f71c: 55 push %ebp <== NOT EXECUTED 10f71d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f71f: 57 push %edi <== NOT EXECUTED 10f720: 56 push %esi <== NOT EXECUTED 10f721: 53 push %ebx <== NOT EXECUTED 10f722: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10f725: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10f728: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10f72b: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED ISR_Level level; bool notify = false; the_message->priority = submit_type; 10f72e: 89 47 08 mov %eax,0x8(%edi) <== NOT EXECUTED switch ( submit_type ) { 10f731: 3d 00 00 00 80 cmp $0x80000000,%eax <== NOT EXECUTED 10f736: 0f 84 94 00 00 00 je 10f7d0 <_CORE_message_queue_Insert_message+0xb4> <== NOT EXECUTED 10f73c: 3d ff ff ff 7f cmp $0x7fffffff,%eax <== NOT EXECUTED 10f741: 74 65 je 10f7a8 <_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; 10f743: 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 10f746: 8d 56 54 lea 0x54(%esi),%edx <== NOT EXECUTED while ( !_Chain_Is_tail( the_header, the_node ) ) { 10f749: 39 da cmp %ebx,%edx <== NOT EXECUTED 10f74b: 75 49 jne 10f796 <_CORE_message_queue_Insert_message+0x7a> <== NOT EXECUTED 10f74d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10f750: 89 d3 mov %edx,%ebx <== NOT EXECUTED continue; } break; } _ISR_Disable( level ); 10f752: 9c pushf <== NOT EXECUTED 10f753: fa cli <== NOT EXECUTED 10f754: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10f755: 8b 56 48 mov 0x48(%esi),%edx <== NOT EXECUTED 10f758: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10f75b: 89 46 48 mov %eax,0x48(%esi) <== NOT EXECUTED 10f75e: 85 d2 test %edx,%edx <== NOT EXECUTED 10f760: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED notify = true; _Chain_Insert_unprotected( the_node->previous, &the_message->Node ); 10f764: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10f767: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED 10f76a: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10f76c: 89 38 mov %edi,(%eax) <== NOT EXECUTED 10f76e: 89 17 mov %edx,(%edi) <== NOT EXECUTED 10f770: 89 7a 04 mov %edi,0x4(%edx) <== NOT EXECUTED _ISR_Enable( level ); 10f773: 51 push %ecx <== NOT EXECUTED 10f774: 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 ) 10f775: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10f779: 74 25 je 10f7a0 <_CORE_message_queue_Insert_message+0x84> <== NOT EXECUTED 10f77b: 8b 4e 60 mov 0x60(%esi),%ecx <== NOT EXECUTED 10f77e: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f780: 74 1e je 10f7a0 <_CORE_message_queue_Insert_message+0x84> <== NOT EXECUTED (*the_message_queue->notify_handler)( the_message_queue->notify_argument ); 10f782: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED 10f785: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10f788: 5a pop %edx <== NOT EXECUTED 10f789: 5b pop %ebx <== NOT EXECUTED 10f78a: 5e pop %esi <== NOT EXECUTED 10f78b: 5f pop %edi <== NOT EXECUTED 10f78c: 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 ); 10f78d: ff e1 jmp *%ecx <== NOT EXECUTED 10f78f: 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; 10f790: 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 ) ) { 10f792: 39 da cmp %ebx,%edx <== NOT EXECUTED 10f794: 74 ba je 10f750 <_CORE_message_queue_Insert_message+0x34> <== NOT EXECUTED this_message = (CORE_message_queue_Buffer_control *) the_node; if ( this_message->priority <= the_message->priority ) { 10f796: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10f799: 7d f5 jge 10f790 <_CORE_message_queue_Insert_message+0x74> <== NOT EXECUTED 10f79b: eb b5 jmp 10f752 <_CORE_message_queue_Insert_message+0x36> <== NOT EXECUTED 10f79d: 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 ); } 10f7a0: 58 pop %eax <== NOT EXECUTED 10f7a1: 5b pop %ebx <== NOT EXECUTED 10f7a2: 5e pop %esi <== NOT EXECUTED 10f7a3: 5f pop %edi <== NOT EXECUTED 10f7a4: c9 leave <== NOT EXECUTED 10f7a5: c3 ret <== NOT EXECUTED 10f7a6: 66 90 xchg %ax,%ax <== NOT EXECUTED the_message->priority = submit_type; switch ( submit_type ) { case CORE_MESSAGE_QUEUE_SEND_REQUEST: _ISR_Disable( level ); 10f7a8: 9c pushf <== NOT EXECUTED 10f7a9: fa cli <== NOT EXECUTED 10f7aa: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10f7ab: 8b 56 48 mov 0x48(%esi),%edx <== NOT EXECUTED 10f7ae: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10f7b1: 89 46 48 mov %eax,0x48(%esi) <== NOT EXECUTED 10f7b4: 85 d2 test %edx,%edx <== NOT EXECUTED 10f7b6: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED 10f7ba: 8d 46 54 lea 0x54(%esi),%eax <== NOT EXECUTED 10f7bd: 89 07 mov %eax,(%edi) <== NOT EXECUTED 10f7bf: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED 10f7c2: 89 7e 58 mov %edi,0x58(%esi) <== NOT EXECUTED 10f7c5: 89 38 mov %edi,(%eax) <== NOT EXECUTED 10f7c7: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED notify = true; _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 10f7ca: 51 push %ecx <== NOT EXECUTED 10f7cb: 9d popf <== NOT EXECUTED 10f7cc: eb a7 jmp 10f775 <_CORE_message_queue_Insert_message+0x59> <== NOT EXECUTED 10f7ce: 66 90 xchg %ax,%ax <== NOT EXECUTED break; case CORE_MESSAGE_QUEUE_URGENT_REQUEST: _ISR_Disable( level ); 10f7d0: 9c pushf <== NOT EXECUTED 10f7d1: fa cli <== NOT EXECUTED 10f7d2: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10f7d3: 8b 56 48 mov 0x48(%esi),%edx <== NOT EXECUTED 10f7d6: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10f7d9: 89 46 48 mov %eax,0x48(%esi) <== NOT EXECUTED 10f7dc: 85 d2 test %edx,%edx <== NOT EXECUTED 10f7de: 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 10f7e2: 8d 46 50 lea 0x50(%esi),%eax <== NOT EXECUTED 10f7e5: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED 10f7e8: 8b 46 50 mov 0x50(%esi),%eax <== NOT EXECUTED 10f7eb: 89 7e 50 mov %edi,0x50(%esi) <== NOT EXECUTED 10f7ee: 89 07 mov %eax,(%edi) <== NOT EXECUTED 10f7f0: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED notify = true; _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 10f7f3: 51 push %ecx <== NOT EXECUTED 10f7f4: 9d popf <== NOT EXECUTED 10f7f5: e9 7b ff ff ff jmp 10f775 <_CORE_message_queue_Insert_message+0x59> <== NOT EXECUTED 0011662c <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 11662c: 55 push %ebp <== NOT EXECUTED 11662d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11662f: 57 push %edi <== NOT EXECUTED 116630: 56 push %esi <== NOT EXECUTED 116631: 53 push %ebx <== NOT EXECUTED 116632: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 116635: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 116638: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 11663b: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 11663e: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 116641: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 116644: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 116647: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 11664a: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED 11664d: 8a 45 18 mov 0x18(%ebp),%al <== NOT EXECUTED 116650: 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; 116653: 8b 15 7c dd 12 00 mov 0x12dd7c,%edx <== NOT EXECUTED executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 116659: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED _ISR_Disable( level ); 116660: 9c pushf <== NOT EXECUTED 116661: fa cli <== NOT EXECUTED 116662: 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( 116663: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 116666: 8b 58 50 mov 0x50(%eax),%ebx <== NOT EXECUTED 116669: 83 c0 54 add $0x54,%eax <== NOT EXECUTED 11666c: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 11666e: 74 7c je 1166ec <_CORE_message_queue_Seize+0xc0> <== NOT EXECUTED 116670: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 116672: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 116675: 89 57 50 mov %edx,0x50(%edi) <== NOT EXECUTED 116678: 89 f8 mov %edi,%eax <== NOT EXECUTED 11667a: 83 c0 50 add $0x50,%eax <== NOT EXECUTED 11667d: 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; 116680: ff 4f 48 decl 0x48(%edi) <== NOT EXECUTED _ISR_Enable( level ); 116683: 56 push %esi <== NOT EXECUTED 116684: 9d popf <== NOT EXECUTED *size_p = the_message->Contents.size; 116685: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 116688: 89 01 mov %eax,(%ecx) <== NOT EXECUTED _Thread_Executing->Wait.count = the_message->priority; 11668a: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 11668d: a1 7c dd 12 00 mov 0x12dd7c,%eax <== NOT EXECUTED 116692: 89 50 24 mov %edx,0x24(%eax) <== NOT EXECUTED _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size_p); 116695: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 116698: 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 11669b: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED 11669d: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 1166a0: 89 c6 mov %eax,%esi <== NOT EXECUTED 1166a2: 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 ); 1166a4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1166a7: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 1166aa: e8 59 ae ff ff call 111508 <_Thread_queue_Dequeue> <== NOT EXECUTED 1166af: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !the_thread ) { 1166b1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1166b4: 85 c0 test %eax,%eax <== NOT EXECUTED 1166b6: 0f 84 84 00 00 00 je 116740 <_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; 1166bc: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED 1166bf: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED the_message->Contents.size = (size_t) the_thread->Wait.option; 1166c2: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED 1166c5: 89 4b 0c mov %ecx,0xc(%ebx) <== NOT EXECUTED 1166c8: 8b 72 2c mov 0x2c(%edx),%esi <== NOT EXECUTED 1166cb: 8b 7d d8 mov -0x28(%ebp),%edi <== NOT EXECUTED 1166ce: 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( 1166d0: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 1166d3: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 1166d6: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 1166d9: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1166dc: 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 ); } 1166df: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1166e2: 5b pop %ebx <== NOT EXECUTED 1166e3: 5e pop %esi <== NOT EXECUTED 1166e4: 5f pop %edi <== NOT EXECUTED 1166e5: 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( 1166e6: e9 61 fe ff ff jmp 11654c <_CORE_message_queue_Insert_message> <== NOT EXECUTED 1166eb: 90 nop <== NOT EXECUTED the_message->priority ); return; } if ( !wait ) { 1166ec: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) <== NOT EXECUTED 1166f0: 75 12 jne 116704 <_CORE_message_queue_Seize+0xd8> <== NOT EXECUTED _ISR_Enable( level ); 1166f2: 56 push %esi <== NOT EXECUTED 1166f3: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 1166f4: 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 ); } 1166fb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1166fe: 5b pop %ebx <== NOT EXECUTED 1166ff: 5e pop %esi <== NOT EXECUTED 116700: 5f pop %edi <== NOT EXECUTED 116701: c9 leave <== NOT EXECUTED 116702: c3 ret <== NOT EXECUTED 116703: 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 116704: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 116707: 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; 11670e: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED executing->Wait.id = id; 116711: 89 7a 20 mov %edi,0x20(%edx) <== NOT EXECUTED executing->Wait.return_argument_second.mutable_object = buffer; 116714: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 116717: 89 7a 2c mov %edi,0x2c(%edx) <== NOT EXECUTED executing->Wait.return_argument = size_p; 11671a: 89 4a 28 mov %ecx,0x28(%edx) <== NOT EXECUTED /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 11671d: 56 push %esi <== NOT EXECUTED 11671e: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 11671f: c7 45 10 94 19 11 00 movl $0x111994,0x10(%ebp) <== NOT EXECUTED 116726: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 116729: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 11672c: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 11672f: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED } 116732: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116735: 5b pop %ebx <== NOT EXECUTED 116736: 5e pop %esi <== NOT EXECUTED 116737: 5f pop %edi <== NOT EXECUTED 116738: 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 ); 116739: e9 06 af ff ff jmp 111644 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 11673e: 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 116740: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 116743: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 116746: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 116749: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 11674c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11674f: 5b pop %ebx <== NOT EXECUTED 116750: 5e pop %esi <== NOT EXECUTED 116751: 5f pop %edi <== NOT EXECUTED 116752: c9 leave <== NOT EXECUTED 116753: e9 90 94 ff ff jmp 10fbe8 <_Chain_Append> <== NOT EXECUTED 0010ae28 <_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 ) { 10ae28: 55 push %ebp <== NOT EXECUTED 10ae29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae2b: 57 push %edi <== NOT EXECUTED 10ae2c: 56 push %esi <== NOT EXECUTED 10ae2d: 53 push %ebx <== NOT EXECUTED 10ae2e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10ae31: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10ae34: 8a 45 20 mov 0x20(%ebp),%al <== NOT EXECUTED 10ae37: 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 ) { 10ae3a: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10ae3d: 39 53 4c cmp %edx,0x4c(%ebx) <== NOT EXECUTED 10ae40: 72 6e jb 10aeb0 <_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 ) { 10ae42: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10ae45: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae47: 74 77 je 10aec0 <_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 < 10ae49: 39 43 44 cmp %eax,0x44(%ebx) <== NOT EXECUTED 10ae4c: 0f 87 be 00 00 00 ja 10af10 <_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 ) { 10ae52: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10ae56: 0f 84 9c 00 00 00 je 10aef8 <_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() ) { 10ae5c: a1 58 f8 11 00 mov 0x11f858,%eax <== NOT EXECUTED 10ae61: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae63: 0f 85 97 00 00 00 jne 10af00 <_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; 10ae69: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED _ISR_Disable( level ); 10ae6e: 9c pushf <== NOT EXECUTED 10ae6f: fa cli <== NOT EXECUTED 10ae70: 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 10ae71: 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; 10ae78: 89 58 44 mov %ebx,0x44(%eax) <== NOT EXECUTED executing->Wait.id = id; 10ae7b: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 10ae7e: 89 70 20 mov %esi,0x20(%eax) <== NOT EXECUTED executing->Wait.return_argument_second.immutable_object = buffer; 10ae81: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10ae84: 89 48 2c mov %ecx,0x2c(%eax) <== NOT EXECUTED executing->Wait.option = (uint32_t) size; 10ae87: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10ae8a: 89 70 30 mov %esi,0x30(%eax) <== NOT EXECUTED executing->Wait.count = submit_type; 10ae8d: 8b 4d 1c mov 0x1c(%ebp),%ecx <== NOT EXECUTED 10ae90: 89 48 24 mov %ecx,0x24(%eax) <== NOT EXECUTED _ISR_Enable( level ); 10ae93: 52 push %edx <== NOT EXECUTED 10ae94: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 10ae95: 50 push %eax <== NOT EXECUTED 10ae96: 68 5c cb 10 00 push $0x10cb5c <== NOT EXECUTED 10ae9b: ff 75 24 pushl 0x24(%ebp) <== NOT EXECUTED 10ae9e: 53 push %ebx <== NOT EXECUTED 10ae9f: e8 68 19 00 00 call 10c80c <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 10aea4: b8 07 00 00 00 mov $0x7,%eax <== NOT EXECUTED 10aea9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aeac: eb 07 jmp 10aeb5 <_CORE_message_queue_Submit+0x8d> <== NOT EXECUTED 10aeae: 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 ) { 10aeb0: 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; } 10aeb5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aeb8: 5b pop %ebx <== NOT EXECUTED 10aeb9: 5e pop %esi <== NOT EXECUTED 10aeba: 5f pop %edi <== NOT EXECUTED 10aebb: c9 leave <== NOT EXECUTED 10aebc: c3 ret <== NOT EXECUTED 10aebd: 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 ); 10aec0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aec3: 53 push %ebx <== NOT EXECUTED 10aec4: e8 07 18 00 00 call 10c6d0 <_Thread_queue_Dequeue> <== NOT EXECUTED 10aec9: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( the_thread ) { 10aecb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aece: 85 c0 test %eax,%eax <== NOT EXECUTED 10aed0: 74 7e je 10af50 <_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 10aed2: 8b 78 2c mov 0x2c(%eax),%edi <== NOT EXECUTED 10aed5: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10aed8: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10aedb: 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; 10aedd: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 10aee0: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10aee3: 89 08 mov %ecx,(%eax) <== NOT EXECUTED the_thread->Wait.count = submit_type; 10aee5: 8b 75 1c mov 0x1c(%ebp),%esi <== NOT EXECUTED 10aee8: 89 72 24 mov %esi,0x24(%edx) <== NOT EXECUTED 10aeeb: 31 c0 xor %eax,%eax <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; } 10aeed: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aef0: 5b pop %ebx <== NOT EXECUTED 10aef1: 5e pop %esi <== NOT EXECUTED 10aef2: 5f pop %edi <== NOT EXECUTED 10aef3: c9 leave <== NOT EXECUTED 10aef4: c3 ret <== NOT EXECUTED 10aef5: 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 ) { 10aef8: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10aefd: eb b6 jmp 10aeb5 <_CORE_message_queue_Submit+0x8d> <== NOT EXECUTED 10aeff: 90 nop <== NOT EXECUTED _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; 10af00: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } 10af05: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10af08: 5b pop %ebx <== NOT EXECUTED 10af09: 5e pop %esi <== NOT EXECUTED 10af0a: 5f pop %edi <== NOT EXECUTED 10af0b: c9 leave <== NOT EXECUTED 10af0c: c3 ret <== NOT EXECUTED 10af0d: 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. 10af10: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af13: 8d 43 68 lea 0x68(%ebx),%eax <== NOT EXECUTED 10af16: 50 push %eax <== NOT EXECUTED 10af17: e8 e4 fe ff ff call 10ae00 <_Chain_Get> <== NOT EXECUTED /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 10af1c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af1f: 85 c0 test %eax,%eax <== NOT EXECUTED 10af21: 74 dd je 10af00 <_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 10af23: 8d 78 10 lea 0x10(%eax),%edi <== NOT EXECUTED 10af26: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10af29: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10af2c: 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; 10af2e: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10af31: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED the_message->priority = submit_type; 10af34: 8b 4d 1c mov 0x1c(%ebp),%ecx <== NOT EXECUTED 10af37: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED _CORE_message_queue_Insert_message( 10af3a: 52 push %edx <== NOT EXECUTED 10af3b: 51 push %ecx <== NOT EXECUTED 10af3c: 50 push %eax <== NOT EXECUTED 10af3d: 53 push %ebx <== NOT EXECUTED 10af3e: e8 d9 47 00 00 call 10f71c <_CORE_message_queue_Insert_message> <== NOT EXECUTED 10af43: 31 c0 xor %eax,%eax <== NOT EXECUTED 10af45: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af48: e9 68 ff ff ff jmp 10aeb5 <_CORE_message_queue_Submit+0x8d> <== NOT EXECUTED 10af4d: 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 ) { 10af50: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10af53: e9 f1 fe ff ff jmp 10ae49 <_CORE_message_queue_Submit+0x21> <== NOT EXECUTED 0010af58 <_CORE_mutex_Flush>: void _CORE_mutex_Flush( CORE_mutex_Control *the_mutex, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 10af58: 55 push %ebp <== NOT EXECUTED 10af59: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Thread_queue_Flush( &the_mutex->Wait_queue, remote_extract_callout, status ); } 10af5b: c9 leave <== NOT EXECUTED CORE_mutex_Control *the_mutex, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { _Thread_queue_Flush( 10af5c: e9 f3 1a 00 00 jmp 10ca54 <_Thread_queue_Flush> <== NOT EXECUTED 0010af64 <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 10af64: 55 push %ebp <== NOT EXECUTED 10af65: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10af67: 57 push %edi <== NOT EXECUTED 10af68: 56 push %esi <== NOT EXECUTED 10af69: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10af6c: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10af6f: 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; 10af72: 8d 7a 40 lea 0x40(%edx),%edi <== NOT EXECUTED 10af75: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10af7a: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10af7d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED the_mutex->lock = initial_lock; 10af7f: 89 42 50 mov %eax,0x50(%edx) <== NOT EXECUTED the_mutex->blocked_count = 0; 10af82: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx) <== NOT EXECUTED if ( initial_lock == CORE_MUTEX_LOCKED ) { 10af89: 85 c0 test %eax,%eax <== NOT EXECUTED 10af8b: 75 33 jne 10afc0 <_CORE_mutex_Initialize+0x5c> <== NOT EXECUTED the_mutex->nest_count = 1; 10af8d: c7 42 54 01 00 00 00 movl $0x1,0x54(%edx) <== NOT EXECUTED the_mutex->holder = _Thread_Executing; 10af94: 8b 0d 7c f8 11 00 mov 0x11f87c,%ecx <== NOT EXECUTED 10af9a: 89 4a 5c mov %ecx,0x5c(%edx) <== NOT EXECUTED the_mutex->holder_id = _Thread_Executing->Object.id; 10af9d: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10afa0: 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 10afa3: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 10afa6: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10afa9: 74 05 je 10afb0 <_CORE_mutex_Initialize+0x4c> <== NOT EXECUTED 10afab: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10afae: 75 25 jne 10afd5 <_CORE_mutex_Initialize+0x71> <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < 10afb0: 8b 41 14 mov 0x14(%ecx),%eax <== NOT EXECUTED 10afb3: 3b 42 4c cmp 0x4c(%edx),%eax <== NOT EXECUTED 10afb6: 72 48 jb 10b000 <_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++; 10afb8: ff 41 1c incl 0x1c(%ecx) <== NOT EXECUTED 10afbb: eb 18 jmp 10afd5 <_CORE_mutex_Initialize+0x71> <== NOT EXECUTED 10afbd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } } else { the_mutex->nest_count = 0; 10afc0: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) <== NOT EXECUTED the_mutex->holder = NULL; 10afc7: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx) <== NOT EXECUTED the_mutex->holder_id = 0; 10afce: c7 42 60 00 00 00 00 movl $0x0,0x60(%edx) <== NOT EXECUTED } _Thread_queue_Initialize( 10afd5: 6a 05 push $0x5 <== NOT EXECUTED 10afd7: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 10afdc: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10afdf: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10afe2: 85 c0 test %eax,%eax <== NOT EXECUTED 10afe4: 0f 95 c0 setne %al <== NOT EXECUTED 10afe7: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10afea: 50 push %eax <== NOT EXECUTED 10afeb: 52 push %edx <== NOT EXECUTED 10afec: e8 8f 1a 00 00 call 10ca80 <_Thread_queue_Initialize> <== NOT EXECUTED 10aff1: 31 c0 xor %eax,%eax <== NOT EXECUTED 10aff3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10aff6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10aff9: 5e pop %esi <== NOT EXECUTED 10affa: 5f pop %edi <== NOT EXECUTED 10affb: c9 leave <== NOT EXECUTED 10affc: c3 ret <== NOT EXECUTED 10affd: 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 < 10b000: b8 06 00 00 00 mov $0x6,%eax <== NOT EXECUTED STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10b005: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b008: 5e pop %esi <== NOT EXECUTED 10b009: 5f pop %edi <== NOT EXECUTED 10b00a: c9 leave <== NOT EXECUTED 10b00b: c3 ret <== NOT EXECUTED 0010b05c <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 10b05c: 55 push %ebp <== NOT EXECUTED 10b05d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b05f: 56 push %esi <== NOT EXECUTED 10b060: 53 push %ebx <== NOT EXECUTED 10b061: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10b064: 8a 5d 10 mov 0x10(%ebp),%bl <== NOT EXECUTED _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10b067: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10b06c: 85 c0 test %eax,%eax <== NOT EXECUTED 10b06e: 74 04 je 10b074 <_CORE_mutex_Seize+0x18> <== NOT EXECUTED 10b070: 84 db test %bl,%bl <== NOT EXECUTED 10b072: 75 30 jne 10b0a4 <_CORE_mutex_Seize+0x48> <== NOT EXECUTED 10b074: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b077: 8d 45 18 lea 0x18(%ebp),%eax <== NOT EXECUTED 10b07a: 50 push %eax <== NOT EXECUTED 10b07b: 56 push %esi <== NOT EXECUTED 10b07c: e8 7b 47 00 00 call 10f7fc <_CORE_mutex_Seize_interrupt_trylock> <== NOT EXECUTED 10b081: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b084: 85 c0 test %eax,%eax <== NOT EXECUTED 10b086: 74 14 je 10b09c <_CORE_mutex_Seize+0x40> <== NOT EXECUTED 10b088: 84 db test %bl,%bl <== NOT EXECUTED 10b08a: 75 30 jne 10b0bc <_CORE_mutex_Seize+0x60> <== NOT EXECUTED 10b08c: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10b08f: 9d popf <== NOT EXECUTED 10b090: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED 10b095: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) <== NOT EXECUTED } 10b09c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b09f: 5b pop %ebx <== NOT EXECUTED 10b0a0: 5e pop %esi <== NOT EXECUTED 10b0a1: c9 leave <== NOT EXECUTED 10b0a2: c3 ret <== NOT EXECUTED 10b0a3: 90 nop <== NOT EXECUTED bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10b0a4: 83 3d 84 f9 11 00 01 cmpl $0x1,0x11f984 <== NOT EXECUTED 10b0ab: 76 c7 jbe 10b074 <_CORE_mutex_Seize+0x18> <== NOT EXECUTED 10b0ad: 53 push %ebx <== NOT EXECUTED 10b0ae: 6a 13 push $0x13 <== NOT EXECUTED 10b0b0: 6a 00 push $0x0 <== NOT EXECUTED 10b0b2: 6a 00 push $0x0 <== NOT EXECUTED 10b0b4: e8 c7 04 00 00 call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED 10b0b9: 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 10b0bc: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi) <== NOT EXECUTED 10b0c3: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED 10b0c8: 89 70 44 mov %esi,0x44(%eax) <== NOT EXECUTED 10b0cb: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10b0ce: 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 10b0d1: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10b0d6: 40 inc %eax <== NOT EXECUTED 10b0d7: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED 10b0dc: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10b0df: 9d popf <== NOT EXECUTED 10b0e0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b0e3: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10b0e6: 56 push %esi <== NOT EXECUTED 10b0e7: e8 20 ff ff ff call 10b00c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 10b0ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b0ef: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b0f2: 5b pop %ebx <== NOT EXECUTED 10b0f3: 5e pop %esi <== NOT EXECUTED 10b0f4: c9 leave <== NOT EXECUTED 10b0f5: c3 ret <== NOT EXECUTED 0010b00c <_CORE_mutex_Seize_interrupt_blocking>: void _CORE_mutex_Seize_interrupt_blocking( CORE_mutex_Control *the_mutex, Watchdog_Interval timeout ) { 10b00c: 55 push %ebp <== NOT EXECUTED 10b00d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b00f: 56 push %esi <== NOT EXECUTED 10b010: 53 push %ebx <== NOT EXECUTED 10b011: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b014: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 10b017: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 10b01c: 83 7b 48 02 cmpl $0x2,0x48(%ebx) <== NOT EXECUTED 10b020: 74 1e je 10b040 <_CORE_mutex_Seize_interrupt_blocking+0x34> <== NOT EXECUTED FALSE ); } } the_mutex->blocked_count++; 10b022: ff 43 58 incl 0x58(%ebx) <== NOT EXECUTED _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 10b025: 50 push %eax <== NOT EXECUTED 10b026: 68 5c cb 10 00 push $0x10cb5c <== NOT EXECUTED 10b02b: 56 push %esi <== NOT EXECUTED 10b02c: 53 push %ebx <== NOT EXECUTED 10b02d: e8 da 17 00 00 call 10c80c <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b032: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b035: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b038: 5b pop %ebx <== NOT EXECUTED 10b039: 5e pop %esi <== NOT EXECUTED 10b03a: c9 leave <== NOT EXECUTED } the_mutex->blocked_count++; _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); _Thread_Enable_dispatch(); 10b03b: e9 0c 13 00 00 jmp 10c34c <_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 ) { 10b040: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED 10b043: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10b046: 39 42 14 cmp %eax,0x14(%edx) <== NOT EXECUTED 10b049: 76 d7 jbe 10b022 <_CORE_mutex_Seize_interrupt_blocking+0x16> <== NOT EXECUTED _Thread_Change_priority( 10b04b: 51 push %ecx <== NOT EXECUTED 10b04c: 6a 00 push $0x0 <== NOT EXECUTED 10b04e: 50 push %eax <== NOT EXECUTED 10b04f: 52 push %edx <== NOT EXECUTED 10b050: e8 1b 0e 00 00 call 10be70 <_Thread_Change_priority> <== NOT EXECUTED 10b055: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b058: eb c8 jmp 10b022 <_CORE_mutex_Seize_interrupt_blocking+0x16> <== NOT EXECUTED 0010f7fc <_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 ) { 10f7fc: 55 push %ebp <== NOT EXECUTED 10f7fd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f7ff: 53 push %ebx <== NOT EXECUTED 10f800: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10f803: 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 ); 10f806: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f809: 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. * 10f80b: 8b 15 7c f8 11 00 mov 0x11f87c,%edx <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10f811: 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 10f818: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED 10f81b: 85 c0 test %eax,%eax <== NOT EXECUTED 10f81d: 74 2d je 10f84c <_CORE_mutex_Seize_interrupt_trylock+0x50> <== NOT EXECUTED * to be resized 10f81f: c7 41 50 00 00 00 00 movl $0x0,0x50(%ecx) <== NOT EXECUTED * @param[in] size is the new size 10f826: 89 51 5c mov %edx,0x5c(%ecx) <== NOT EXECUTED * 10f829: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10f82c: 89 41 60 mov %eax,0x60(%ecx) <== NOT EXECUTED * @return TRUE if successfully able to resize the block. 10f82f: 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 10f836: 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. 10f839: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10f83c: 74 1e je 10f85c <_CORE_mutex_Seize_interrupt_trylock+0x60> <== NOT EXECUTED 10f83e: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10f841: 74 19 je 10f85c <_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 10f843: 53 push %ebx <== NOT EXECUTED 10f844: 9d popf <== NOT EXECUTED 10f845: 31 c0 xor %eax,%eax <== NOT EXECUTED return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); } 10f847: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f84a: c9 leave <== NOT EXECUTED 10f84b: 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. 10f84c: 3b 51 5c cmp 0x5c(%ecx),%edx <== NOT EXECUTED 10f84f: 74 3f je 10f890 <_CORE_mutex_Seize_interrupt_trylock+0x94> <== NOT EXECUTED Heap_Control *the_heap, Heap_Information *info ); #ifdef __cplusplus } 10f851: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10f856: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f859: c9 leave <== NOT EXECUTED 10f85a: c3 ret <== NOT EXECUTED 10f85b: 90 nop <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10f85c: 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. * 10f85f: 83 79 48 03 cmpl $0x3,0x48(%ecx) <== NOT EXECUTED 10f863: 75 de jne 10f843 <_CORE_mutex_Seize_interrupt_trylock+0x47> <== NOT EXECUTED void *start_address ); /** * This routine walks the heap to verify its integrity. * 10f865: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10f868: 39 41 4c cmp %eax,0x4c(%ecx) <== NOT EXECUTED 10f86b: 74 47 je 10f8b4 <_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. */ 10f86d: 72 4d jb 10f8bc <_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 10f86f: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) <== NOT EXECUTED * 10f876: c7 41 50 01 00 00 00 movl $0x1,0x50(%ecx) <== NOT EXECUTED * @return true if successfully able to return information 10f87d: c7 41 54 00 00 00 00 movl $0x0,0x54(%ecx) <== NOT EXECUTED */ 10f884: ff 4a 1c decl 0x1c(%edx) <== NOT EXECUTED bool _Protected_heap_Get_information( 10f887: 53 push %ebx <== NOT EXECUTED 10f888: 9d popf <== NOT EXECUTED 10f889: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f88b: eb c9 jmp 10f856 <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 10f88d: 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. */ 10f890: 8b 41 40 mov 0x40(%ecx),%eax <== NOT EXECUTED 10f893: 85 c0 test %eax,%eax <== NOT EXECUTED 10f895: 74 11 je 10f8a8 <_CORE_mutex_Seize_interrupt_trylock+0xac> <== NOT EXECUTED 10f897: 48 dec %eax <== NOT EXECUTED 10f898: 75 b7 jne 10f851 <_CORE_mutex_Seize_interrupt_trylock+0x55> <== NOT EXECUTED bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ); #ifdef __cplusplus 10f89a: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) <== NOT EXECUTED } 10f8a1: 53 push %ebx <== NOT EXECUTED 10f8a2: 9d popf <== NOT EXECUTED 10f8a3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f8a5: eb af jmp 10f856 <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 10f8a7: 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, 10f8a8: ff 41 54 incl 0x54(%ecx) <== NOT EXECUTED Heap_Information *info 10f8ab: 53 push %ebx <== NOT EXECUTED 10f8ac: 9d popf <== NOT EXECUTED 10f8ad: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f8af: eb a5 jmp 10f856 <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 10f8b1: 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 10f8b4: 53 push %ebx <== NOT EXECUTED 10f8b5: 9d popf <== NOT EXECUTED 10f8b6: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f8b8: eb 9c jmp 10f856 <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 10f8ba: 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 10f8bc: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10f8c1: 40 inc %eax <== NOT EXECUTED 10f8c2: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== 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, 10f8c7: 53 push %ebx <== NOT EXECUTED 10f8c8: 9d popf <== NOT EXECUTED int source, 10f8c9: 50 push %eax <== NOT EXECUTED 10f8ca: 6a 00 push $0x0 <== NOT EXECUTED 10f8cc: ff 71 4c pushl 0x4c(%ecx) <== NOT EXECUTED 10f8cf: ff 71 5c pushl 0x5c(%ecx) <== NOT EXECUTED 10f8d2: e8 99 c5 ff ff call 10be70 <_Thread_Change_priority> <== NOT EXECUTED bool do_dump ); /** * This routine walks the heap and tots up the free and allocated 10f8d7: e8 70 ca ff ff call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED 10f8dc: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f8de: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f8e1: e9 70 ff ff ff jmp 10f856 <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 0010b0f8 <_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 ) { 10b0f8: 55 push %ebp <== NOT EXECUTED 10b0f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b0fb: 53 push %ebx <== NOT EXECUTED 10b0fc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b0ff: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Thread_Control *the_thread; Thread_Control *holder; #ifdef __RTEMS_STRICT_ORDER_MUTEX__ Chain_Node *first_node; #endif holder = the_mutex->holder; 10b102: 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 ) { 10b105: 80 7b 44 00 cmpb $0x0,0x44(%ebx) <== NOT EXECUTED 10b109: 74 15 je 10b120 <_CORE_mutex_Surrender+0x28> <== NOT EXECUTED if ( !_Thread_Is_executing( holder ) ) 10b10b: 3b 15 7c f8 11 00 cmp 0x11f87c,%edx <== NOT EXECUTED 10b111: 74 0d je 10b120 <_CORE_mutex_Surrender+0x28> <== NOT EXECUTED 10b113: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 10b118: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b11b: c9 leave <== NOT EXECUTED 10b11c: c3 ret <== NOT EXECUTED 10b11d: 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 ) 10b120: 8b 43 54 mov 0x54(%ebx),%eax <== NOT EXECUTED 10b123: 85 c0 test %eax,%eax <== NOT EXECUTED 10b125: 74 69 je 10b190 <_CORE_mutex_Surrender+0x98> <== NOT EXECUTED return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 10b127: 48 dec %eax <== NOT EXECUTED 10b128: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED if ( the_mutex->nest_count != 0 ) { 10b12b: 85 c0 test %eax,%eax <== NOT EXECUTED 10b12d: 75 69 jne 10b198 <_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 10b12f: 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 ) || 10b132: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b135: 0f 84 91 00 00 00 je 10b1cc <_CORE_mutex_Surrender+0xd4> <== NOT EXECUTED 10b13b: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b13e: 0f 84 88 00 00 00 je 10b1cc <_CORE_mutex_Surrender+0xd4> <== NOT EXECUTED } first_node = _Chain_Get_first_unprotected(&holder->lock_mutex); #endif holder->resource_count--; } the_mutex->holder = NULL; 10b144: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = 0; 10b14b: 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 ) || 10b152: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b155: 74 55 je 10b1ac <_CORE_mutex_Surrender+0xb4> <== NOT EXECUTED 10b157: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b15a: 74 50 je 10b1ac <_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 ) ) ) { 10b15c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b15f: 53 push %ebx <== NOT EXECUTED 10b160: e8 6b 15 00 00 call 10c6d0 <_Thread_queue_Dequeue> <== NOT EXECUTED 10b165: 89 c2 mov %eax,%edx <== NOT EXECUTED 10b167: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b16a: 85 c0 test %eax,%eax <== NOT EXECUTED 10b16c: 0f 84 8e 00 00 00 je 10b200 <_CORE_mutex_Surrender+0x108> <== NOT EXECUTED } else #endif { the_mutex->holder = the_thread; 10b172: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = the_thread->Object.id; 10b175: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10b178: 89 43 60 mov %eax,0x60(%ebx) <== NOT EXECUTED the_mutex->nest_count = 1; 10b17b: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx) <== NOT EXECUTED switch ( the_mutex->Attributes.discipline ) { 10b182: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10b185: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b188: 74 6a je 10b1f4 <_CORE_mutex_Surrender+0xfc> <== NOT EXECUTED 10b18a: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b18d: 74 45 je 10b1d4 <_CORE_mutex_Surrender+0xdc> <== NOT EXECUTED 10b18f: 90 nop <== NOT EXECUTED } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 10b190: 31 c0 xor %eax,%eax <== NOT EXECUTED return CORE_MUTEX_STATUS_SUCCESSFUL; } 10b192: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b195: c9 leave <== NOT EXECUTED 10b196: c3 ret <== NOT EXECUTED 10b197: 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 ) { 10b198: 8b 43 40 mov 0x40(%ebx),%eax <== NOT EXECUTED 10b19b: 85 c0 test %eax,%eax <== NOT EXECUTED 10b19d: 74 f1 je 10b190 <_CORE_mutex_Surrender+0x98> <== NOT EXECUTED 10b19f: 48 dec %eax <== NOT EXECUTED 10b1a0: 75 8d jne 10b12f <_CORE_mutex_Surrender+0x37> <== NOT EXECUTED 10b1a2: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10b1a7: e9 6c ff ff ff jmp 10b118 <_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 && 10b1ac: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 10b1af: 85 c0 test %eax,%eax <== NOT EXECUTED 10b1b1: 75 a9 jne 10b15c <_CORE_mutex_Surrender+0x64> <== NOT EXECUTED 10b1b3: 8b 42 18 mov 0x18(%edx),%eax <== NOT EXECUTED 10b1b6: 3b 42 14 cmp 0x14(%edx),%eax <== NOT EXECUTED 10b1b9: 74 a1 je 10b15c <_CORE_mutex_Surrender+0x64> <== NOT EXECUTED holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 10b1bb: 51 push %ecx <== NOT EXECUTED 10b1bc: 6a 01 push $0x1 <== NOT EXECUTED 10b1be: 50 push %eax <== NOT EXECUTED 10b1bf: 52 push %edx <== NOT EXECUTED 10b1c0: e8 ab 0c 00 00 call 10be70 <_Thread_Change_priority> <== NOT EXECUTED 10b1c5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b1c8: eb 92 jmp 10b15c <_CORE_mutex_Surrender+0x64> <== NOT EXECUTED 10b1ca: 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--; 10b1cc: ff 4a 1c decl 0x1c(%edx) <== NOT EXECUTED 10b1cf: e9 70 ff ff ff jmp 10b144 <_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++; 10b1d4: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED if (the_mutex->Attributes.priority_ceiling < 10b1d7: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 10b1da: 3b 42 14 cmp 0x14(%edx),%eax <== NOT EXECUTED 10b1dd: 73 b1 jae 10b190 <_CORE_mutex_Surrender+0x98> <== NOT EXECUTED the_thread->current_priority){ _Thread_Change_priority( 10b1df: 51 push %ecx <== NOT EXECUTED 10b1e0: 6a 00 push $0x0 <== NOT EXECUTED 10b1e2: 50 push %eax <== NOT EXECUTED 10b1e3: 52 push %edx <== NOT EXECUTED 10b1e4: e8 87 0c 00 00 call 10be70 <_Thread_Change_priority> <== NOT EXECUTED 10b1e9: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b1eb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b1ee: e9 25 ff ff ff jmp 10b118 <_CORE_mutex_Surrender+0x20> <== NOT EXECUTED 10b1f3: 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++; 10b1f4: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED 10b1f7: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b1f9: e9 1a ff ff ff jmp 10b118 <_CORE_mutex_Surrender+0x20> <== NOT EXECUTED 10b1fe: 66 90 xchg %ax,%ax <== NOT EXECUTED } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 10b200: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx) <== NOT EXECUTED 10b207: 31 c0 xor %eax,%eax 10b209: e9 0a ff ff ff jmp 10b118 <_CORE_mutex_Surrender+0x20> <== NOT EXECUTED 0010b210 <_CORE_semaphore_Flush>: void _CORE_semaphore_Flush( CORE_semaphore_Control *the_semaphore, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 10b210: 55 push %ebp <== NOT EXECUTED 10b211: 89 e5 mov %esp,%ebp <== NOT EXECUTED &the_semaphore->Wait_queue, remote_extract_callout, status ); } 10b213: c9 leave <== NOT EXECUTED Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { _Thread_queue_Flush( 10b214: e9 3b 18 00 00 jmp 10ca54 <_Thread_queue_Flush> <== NOT EXECUTED 0010b21c <_CORE_semaphore_Initialize>: void _CORE_semaphore_Initialize( CORE_semaphore_Control *the_semaphore, CORE_semaphore_Attributes *the_semaphore_attributes, uint32_t initial_value ) { 10b21c: 55 push %ebp <== NOT EXECUTED 10b21d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b21f: 53 push %ebx <== NOT EXECUTED 10b220: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b223: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b226: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED the_semaphore->Attributes = *the_semaphore_attributes; 10b229: 8b 1a mov (%edx),%ebx <== NOT EXECUTED 10b22b: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10b22e: 89 41 44 mov %eax,0x44(%ecx) <== NOT EXECUTED 10b231: 89 59 40 mov %ebx,0x40(%ecx) <== NOT EXECUTED the_semaphore->count = initial_value; 10b234: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b237: 89 41 48 mov %eax,0x48(%ecx) <== NOT EXECUTED _Thread_queue_Initialize( 10b23a: 6a 03 push $0x3 <== NOT EXECUTED 10b23c: 68 00 02 00 00 push $0x200 <== NOT EXECUTED 10b241: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b243: 83 7a 04 01 cmpl $0x1,0x4(%edx) <== NOT EXECUTED 10b247: 0f 94 c0 sete %al <== NOT EXECUTED 10b24a: 50 push %eax <== NOT EXECUTED 10b24b: 51 push %ecx <== NOT EXECUTED 10b24c: e8 2f 18 00 00 call 10ca80 <_Thread_queue_Initialize> <== NOT EXECUTED 10b251: 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 ); } 10b254: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b257: c9 leave <== NOT EXECUTED 10b258: c3 ret <== NOT EXECUTED 00112f88 <_CORE_semaphore_Seize>: CORE_semaphore_Control *the_semaphore, Objects_Id id, bool wait, Watchdog_Interval timeout ) { 112f88: 55 push %ebp <== NOT EXECUTED 112f89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112f8b: 57 push %edi <== NOT EXECUTED 112f8c: 56 push %esi <== NOT EXECUTED 112f8d: 53 push %ebx <== NOT EXECUTED 112f8e: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 112f91: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 112f94: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 112f97: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 112f9a: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 112f9d: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 112fa0: 8b 15 9c 59 12 00 mov 0x12599c,%edx <== NOT EXECUTED executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 112fa6: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED _ISR_Disable( level ); 112fad: 9c pushf <== NOT EXECUTED 112fae: fa cli <== NOT EXECUTED 112faf: 5b pop %ebx <== NOT EXECUTED if ( the_semaphore->count != 0 ) { 112fb0: 8b 41 48 mov 0x48(%ecx),%eax <== NOT EXECUTED 112fb3: 85 c0 test %eax,%eax <== NOT EXECUTED 112fb5: 75 15 jne 112fcc <_CORE_semaphore_Seize+0x44> <== NOT EXECUTED /* * If the semaphore was not available and the caller was not willing * to block, then return immediately with a status indicating that * the semaphore was not available and the caller never blocked. */ if ( !wait ) { 112fb7: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 112fbb: 75 1b jne 112fd8 <_CORE_semaphore_Seize+0x50> <== NOT EXECUTED _ISR_Enable( level ); 112fbd: 53 push %ebx <== NOT EXECUTED 112fbe: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 112fbf: c7 42 34 01 00 00 00 movl $0x1,0x34(%edx) <== NOT EXECUTED _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); } 112fc6: 58 pop %eax <== NOT EXECUTED 112fc7: 5b pop %ebx <== NOT EXECUTED 112fc8: 5e pop %esi <== NOT EXECUTED 112fc9: 5f pop %edi <== NOT EXECUTED 112fca: c9 leave <== NOT EXECUTED 112fcb: c3 ret <== NOT EXECUTED executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; _ISR_Disable( level ); if ( the_semaphore->count != 0 ) { the_semaphore->count -= 1; 112fcc: 48 dec %eax <== NOT EXECUTED 112fcd: 89 41 48 mov %eax,0x48(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 112fd0: 53 push %ebx <== NOT EXECUTED 112fd1: 9d popf <== NOT EXECUTED _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); } 112fd2: 58 pop %eax <== NOT EXECUTED 112fd3: 5b pop %ebx <== NOT EXECUTED 112fd4: 5e pop %esi <== NOT EXECUTED 112fd5: 5f pop %edi <== NOT EXECUTED 112fd6: c9 leave <== NOT EXECUTED 112fd7: 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 112fd8: c7 41 30 01 00 00 00 movl $0x1,0x30(%ecx) <== NOT EXECUTED /* * If the semaphore is not available and the caller is willing to * block, then we now block the caller with optional timeout. */ _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; 112fdf: 89 4a 44 mov %ecx,0x44(%edx) <== NOT EXECUTED executing->Wait.id = id; 112fe2: 89 72 20 mov %esi,0x20(%edx) <== NOT EXECUTED _ISR_Enable( level ); 112fe5: 53 push %ebx <== NOT EXECUTED 112fe6: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 112fe7: c7 45 10 74 fb 10 00 movl $0x10fb74,0x10(%ebp) <== NOT EXECUTED 112fee: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED 112ff1: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 112ff4: 5a pop %edx <== NOT EXECUTED 112ff5: 5b pop %ebx <== NOT EXECUTED 112ff6: 5e pop %esi <== NOT EXECUTED 112ff7: 5f pop %edi <== NOT EXECUTED 112ff8: c9 leave <== NOT EXECUTED */ _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 112ff9: e9 26 c8 ff ff jmp 10f824 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 0010b25c <_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 ) { 10b25c: 55 push %ebp <== NOT EXECUTED 10b25d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b25f: 53 push %ebx <== NOT EXECUTED 10b260: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10b263: 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)) ) { 10b266: 53 push %ebx <== NOT EXECUTED 10b267: e8 64 14 00 00 call 10c6d0 <_Thread_queue_Dequeue> <== NOT EXECUTED 10b26c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b26f: 85 c0 test %eax,%eax <== NOT EXECUTED 10b271: 74 09 je 10b27c <_CORE_semaphore_Surrender+0x20> <== NOT EXECUTED 10b273: 31 c0 xor %eax,%eax <== NOT EXECUTED status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); } return status; } 10b275: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b278: c9 leave <== NOT EXECUTED 10b279: c3 ret <== NOT EXECUTED 10b27a: 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 ); 10b27c: 9c pushf <== NOT EXECUTED 10b27d: fa cli <== NOT EXECUTED 10b27e: 5a pop %edx <== NOT EXECUTED if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10b27f: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10b282: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 10b285: 72 0d jb 10b294 <_CORE_semaphore_Surrender+0x38> <== NOT EXECUTED 10b287: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); 10b28c: 52 push %edx <== NOT EXECUTED 10b28d: 9d popf <== NOT EXECUTED } return status; } 10b28e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b291: c9 leave <== NOT EXECUTED 10b292: c3 ret <== NOT EXECUTED 10b293: 90 nop <== NOT EXECUTED #endif } else { _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) the_semaphore->count += 1; 10b294: 40 inc %eax <== NOT EXECUTED 10b295: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 10b298: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b29a: eb f0 jmp 10b28c <_CORE_semaphore_Surrender+0x30> <== NOT EXECUTED 0010bbc0 <_CORE_spinlock_Initialize>: void _CORE_spinlock_Initialize( CORE_spinlock_Control *the_spinlock, CORE_spinlock_Attributes *the_spinlock_attributes ) { 10bbc0: 55 push %ebp <== NOT EXECUTED 10bbc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bbc3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED the_spinlock->Attributes = *the_spinlock_attributes; 10bbc6: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10bbc9: 8b 12 mov (%edx),%edx <== NOT EXECUTED 10bbcb: 89 10 mov %edx,(%eax) <== NOT EXECUTED the_spinlock->lock = 0; 10bbcd: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED the_spinlock->users = 0; 10bbd4: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) <== NOT EXECUTED the_spinlock->holder = 0; 10bbdb: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) <== NOT EXECUTED } 10bbe2: c9 leave <== NOT EXECUTED 10bbe3: c3 ret <== NOT EXECUTED 0010bbe4 <_CORE_spinlock_Release>: */ CORE_spinlock_Status _CORE_spinlock_Release( CORE_spinlock_Control *the_spinlock ) { 10bbe4: 55 push %ebp <== NOT EXECUTED 10bbe5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bbe7: 53 push %ebx <== NOT EXECUTED 10bbe8: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10bbeb: 9c pushf <== NOT EXECUTED 10bbec: fa cli <== NOT EXECUTED 10bbed: 59 pop %ecx <== NOT EXECUTED /* * It must locked before it can be unlocked. */ if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 10bbee: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10bbf1: 85 c0 test %eax,%eax <== NOT EXECUTED 10bbf3: 75 07 jne 10bbfc <_CORE_spinlock_Release+0x18> <== NOT EXECUTED _ISR_Enable( level ); 10bbf5: 51 push %ecx <== NOT EXECUTED 10bbf6: 9d popf <== NOT EXECUTED 10bbf7: b0 06 mov $0x6,%al <== NOT EXECUTED the_spinlock->lock = CORE_SPINLOCK_UNLOCKED; the_spinlock->holder = 0; _ISR_Enable( level ); return CORE_SPINLOCK_SUCCESSFUL; } 10bbf9: 5b pop %ebx <== NOT EXECUTED 10bbfa: c9 leave <== NOT EXECUTED 10bbfb: c3 ret <== NOT EXECUTED } /* * It must locked by the current thread before it can be unlocked. */ if ( the_spinlock->holder != _Thread_Executing->Object.id ) { 10bbfc: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED 10bbff: a1 7c 09 12 00 mov 0x12097c,%eax <== NOT EXECUTED 10bc04: 3b 50 08 cmp 0x8(%eax),%edx <== NOT EXECUTED 10bc07: 74 0b je 10bc14 <_CORE_spinlock_Release+0x30> <== NOT EXECUTED _ISR_Enable( level ); 10bc09: 51 push %ecx <== NOT EXECUTED 10bc0a: 9d popf <== NOT EXECUTED 10bc0b: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED the_spinlock->lock = CORE_SPINLOCK_UNLOCKED; the_spinlock->holder = 0; _ISR_Enable( level ); return CORE_SPINLOCK_SUCCESSFUL; } 10bc10: 5b pop %ebx <== NOT EXECUTED 10bc11: c9 leave <== NOT EXECUTED 10bc12: c3 ret <== NOT EXECUTED 10bc13: 90 nop <== NOT EXECUTED } /* * Let it be unlocked. */ the_spinlock->users -= 1; 10bc14: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10bc17: 48 dec %eax <== NOT EXECUTED 10bc18: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED the_spinlock->lock = CORE_SPINLOCK_UNLOCKED; 10bc1b: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED the_spinlock->holder = 0; 10bc22: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10bc29: 51 push %ecx <== NOT EXECUTED 10bc2a: 9d popf <== NOT EXECUTED 10bc2b: 31 c0 xor %eax,%eax 10bc2d: eb ca jmp 10bbf9 <_CORE_spinlock_Release+0x15> <== NOT EXECUTED 0010bc30 <_CORE_spinlock_Wait>: CORE_spinlock_Status _CORE_spinlock_Wait( CORE_spinlock_Control *the_spinlock, bool wait, Watchdog_Interval timeout ) { 10bc30: 55 push %ebp <== NOT EXECUTED 10bc31: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc33: 57 push %edi <== NOT EXECUTED 10bc34: 56 push %esi <== NOT EXECUTED 10bc35: 53 push %ebx <== NOT EXECUTED 10bc36: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bc39: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bc3c: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10bc3f: 8a 45 0c mov 0xc(%ebp),%al <== NOT EXECUTED 10bc42: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED ISR_Level level; Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout; 10bc45: a1 24 0a 12 00 mov 0x120a24,%eax <== NOT EXECUTED 10bc4a: 8d 34 07 lea (%edi,%eax,1),%esi <== NOT EXECUTED _ISR_Disable( level ); 10bc4d: 9c pushf <== NOT EXECUTED 10bc4e: fa cli <== NOT EXECUTED 10bc4f: 59 pop %ecx <== NOT EXECUTED if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) && 10bc50: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10bc53: 48 dec %eax <== NOT EXECUTED 10bc54: 74 76 je 10bccc <_CORE_spinlock_Wait+0x9c> <== NOT EXECUTED (the_spinlock->holder == _Thread_Executing->Object.id) ) { _ISR_Enable( level ); return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; 10bc56: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10bc59: 40 inc %eax <== NOT EXECUTED 10bc5a: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED for ( ;; ) { if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 10bc5d: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10bc60: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc62: 74 31 je 10bc95 <_CORE_spinlock_Wait+0x65> <== NOT EXECUTED } /* * Spinlock is unavailable. If not willing to wait, return. */ if ( !wait ) { 10bc64: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10bc68: 74 49 je 10bcb3 <_CORE_spinlock_Wait+0x83> <== NOT EXECUTED 10bc6a: 66 90 xchg %ax,%ax <== NOT EXECUTED } /* * They are willing to wait but there could be a timeout. */ if ( timeout && (limit <= _Watchdog_Ticks_since_boot) ) { 10bc6c: 85 ff test %edi,%edi <== NOT EXECUTED 10bc6e: 74 09 je 10bc79 <_CORE_spinlock_Wait+0x49> <== NOT EXECUTED 10bc70: a1 24 0a 12 00 mov 0x120a24,%eax <== NOT EXECUTED 10bc75: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10bc77: 76 6f jbe 10bce8 <_CORE_spinlock_Wait+0xb8> <== NOT EXECUTED * * A spinlock cannot be deleted while it is being used so we are * safe from deletion. */ _ISR_Enable( level ); 10bc79: 51 push %ecx <== NOT EXECUTED 10bc7a: 9d popf <== NOT EXECUTED /* An ISR could occur here */ _Thread_Enable_dispatch(); 10bc7b: e8 30 11 00 00 call 10cdb0 <_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 10bc80: a1 b8 08 12 00 mov 0x1208b8,%eax <== NOT EXECUTED 10bc85: 40 inc %eax <== NOT EXECUTED 10bc86: a3 b8 08 12 00 mov %eax,0x1208b8 <== NOT EXECUTED /* Another thread could get dispatched here */ /* Reenter the critical sections so we can attempt the lock again. */ _Thread_Disable_dispatch(); _ISR_Disable( level ); 10bc8b: 9c pushf <== NOT EXECUTED 10bc8c: fa cli <== NOT EXECUTED 10bc8d: 59 pop %ecx <== NOT EXECUTED _ISR_Enable( level ); return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; for ( ;; ) { if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 10bc8e: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10bc91: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc93: 75 d7 jne 10bc6c <_CORE_spinlock_Wait+0x3c> <== NOT EXECUTED the_spinlock->lock = CORE_SPINLOCK_LOCKED; 10bc95: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) <== NOT EXECUTED the_spinlock->holder = _Thread_Executing->Object.id; 10bc9c: a1 7c 09 12 00 mov 0x12097c,%eax <== NOT EXECUTED 10bca1: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10bca4: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10bca7: 51 push %ecx <== NOT EXECUTED 10bca8: 9d popf <== NOT EXECUTED 10bca9: 31 c0 xor %eax,%eax <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Disable( level ); } } 10bcab: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10bcae: 5b pop %ebx <== NOT EXECUTED 10bcaf: 5e pop %esi <== NOT EXECUTED 10bcb0: 5f pop %edi <== NOT EXECUTED 10bcb1: c9 leave <== NOT EXECUTED 10bcb2: c3 ret <== NOT EXECUTED /* * Spinlock is unavailable. If not willing to wait, return. */ if ( !wait ) { the_spinlock->users -= 1; 10bcb3: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10bcb6: 48 dec %eax <== NOT EXECUTED 10bcb7: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10bcba: 51 push %ecx <== NOT EXECUTED 10bcbb: 9d popf <== NOT EXECUTED 10bcbc: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Disable( level ); } } 10bcc1: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10bcc4: 5b pop %ebx <== NOT EXECUTED 10bcc5: 5e pop %esi <== NOT EXECUTED 10bcc6: 5f pop %edi <== NOT EXECUTED 10bcc7: c9 leave <== NOT EXECUTED 10bcc8: c3 ret <== NOT EXECUTED 10bcc9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { ISR_Level level; Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout; _ISR_Disable( level ); if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) && 10bccc: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED 10bccf: a1 7c 09 12 00 mov 0x12097c,%eax <== NOT EXECUTED 10bcd4: 3b 50 08 cmp 0x8(%eax),%edx <== NOT EXECUTED 10bcd7: 0f 85 79 ff ff ff jne 10bc56 <_CORE_spinlock_Wait+0x26> <== NOT EXECUTED (the_spinlock->holder == _Thread_Executing->Object.id) ) { _ISR_Enable( level ); 10bcdd: 51 push %ecx <== NOT EXECUTED 10bcde: 9d popf <== NOT EXECUTED 10bcdf: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10bce4: eb c5 jmp 10bcab <_CORE_spinlock_Wait+0x7b> <== NOT EXECUTED 10bce6: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * They are willing to wait but there could be a timeout. */ if ( timeout && (limit <= _Watchdog_Ticks_since_boot) ) { the_spinlock->users -= 1; 10bce8: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10bceb: 48 dec %eax <== NOT EXECUTED 10bcec: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10bcef: 51 push %ecx <== NOT EXECUTED 10bcf0: 9d popf <== NOT EXECUTED 10bcf1: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Disable( level ); } } 10bcf6: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10bcf9: 5b pop %ebx <== NOT EXECUTED 10bcfa: 5e pop %esi <== NOT EXECUTED 10bcfb: 5f pop %edi <== NOT EXECUTED 10bcfc: c9 leave <== NOT EXECUTED 10bcfd: c3 ret <== NOT EXECUTED 0010addc <_Chain_Append>: void _Chain_Append( Chain_Control *the_chain, Chain_Node *node ) { 10addc: 55 push %ebp <== NOT EXECUTED 10addd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10addf: 53 push %ebx <== NOT EXECUTED 10ade0: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ade3: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10ade6: 9c pushf <== NOT EXECUTED 10ade7: fa cli <== NOT EXECUTED 10ade8: 5b pop %ebx <== NOT EXECUTED 10ade9: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10adec: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10adee: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10adf1: 89 51 08 mov %edx,0x8(%ecx) <== NOT EXECUTED 10adf4: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10adf6: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED _Chain_Append_unprotected( the_chain, node ); _ISR_Enable( level ); 10adf9: 53 push %ebx <== NOT EXECUTED 10adfa: 9d popf <== NOT EXECUTED } 10adfb: 5b pop %ebx <== NOT EXECUTED 10adfc: c9 leave <== NOT EXECUTED 10adfd: c3 ret <== NOT EXECUTED 0010f6b8 <_Chain_Extract>: */ void _Chain_Extract( Chain_Node *node ) { 10f6b8: 55 push %ebp <== NOT EXECUTED 10f6b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f6bb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10f6be: 9c pushf <== NOT EXECUTED 10f6bf: fa cli <== NOT EXECUTED 10f6c0: 59 pop %ecx <== NOT EXECUTED 10f6c1: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10f6c3: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10f6c6: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10f6c9: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Chain_Extract_unprotected( node ); _ISR_Enable( level ); 10f6cb: 51 push %ecx <== NOT EXECUTED 10f6cc: 9d popf <== NOT EXECUTED } 10f6cd: c9 leave <== NOT EXECUTED 10f6ce: c3 ret <== NOT EXECUTED 0010ae00 <_Chain_Get>: */ Chain_Node *_Chain_Get( Chain_Control *the_chain ) { 10ae00: 55 push %ebp <== NOT EXECUTED 10ae01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae03: 53 push %ebx <== NOT EXECUTED 10ae04: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Chain_Node *return_node; return_node = NULL; _ISR_Disable( level ); 10ae07: 9c pushf <== NOT EXECUTED 10ae08: fa cli <== NOT EXECUTED 10ae09: 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( 10ae0a: 8b 11 mov (%ecx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( the_chain ) ) 10ae0c: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10ae0f: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10ae11: 74 11 je 10ae24 <_Chain_Get+0x24> <== NOT EXECUTED 10ae13: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10ae15: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10ae17: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED return_node = _Chain_Get_first_unprotected( the_chain ); _ISR_Enable( level ); 10ae1a: 53 push %ebx <== NOT EXECUTED 10ae1b: 9d popf <== NOT EXECUTED return return_node; } 10ae1c: 89 d0 mov %edx,%eax <== NOT EXECUTED 10ae1e: 5b pop %ebx <== NOT EXECUTED 10ae1f: c9 leave <== NOT EXECUTED 10ae20: c3 ret <== NOT EXECUTED 10ae21: 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 ) ) 10ae24: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ae26: eb f2 jmp 10ae1a <_Chain_Get+0x1a> <== NOT EXECUTED 0010f6d0 <_Chain_Initialize>: Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 10f6d0: 55 push %ebp <== NOT EXECUTED 10f6d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f6d3: 57 push %edi <== NOT EXECUTED 10f6d4: 56 push %esi <== NOT EXECUTED 10f6d5: 53 push %ebx <== NOT EXECUTED 10f6d6: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10f6d9: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10f6dc: 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 10f6df: 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; 10f6e1: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) <== NOT EXECUTED next = starting_address; while ( count-- ) { 10f6e8: 85 c0 test %eax,%eax <== NOT EXECUTED 10f6ea: 74 22 je 10f70e <_Chain_Initialize+0x3e> <== NOT EXECUTED 10f6ec: 8d 50 ff lea -0x1(%eax),%edx <== NOT EXECUTED 10f6ef: 89 d7 mov %edx,%edi <== NOT EXECUTED 10f6f1: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f6f4: eb 03 jmp 10f6f9 <_Chain_Initialize+0x29> <== NOT EXECUTED 10f6f6: 66 90 xchg %ax,%ax <== NOT EXECUTED 10f6f8: 4a dec %edx <== NOT EXECUTED current->next = next; 10f6f9: 89 01 mov %eax,(%ecx) <== NOT EXECUTED next->previous = current; 10f6fb: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 10f6fe: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10f700: 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-- ) { 10f702: 85 d2 test %edx,%edx <== NOT EXECUTED 10f704: 75 f2 jne 10f6f8 <_Chain_Initialize+0x28> <== NOT EXECUTED 10f706: 0f af df imul %edi,%ebx <== NOT EXECUTED 10f709: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10f70c: 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 ); 10f70e: 8d 46 04 lea 0x4(%esi),%eax <== NOT EXECUTED 10f711: 89 01 mov %eax,(%ecx) <== NOT EXECUTED the_chain->last = current; 10f713: 89 4e 08 mov %ecx,0x8(%esi) <== NOT EXECUTED } 10f716: 5b pop %ebx <== NOT EXECUTED 10f717: 5e pop %esi <== NOT EXECUTED 10f718: 5f pop %edi <== NOT EXECUTED 10f719: c9 leave <== NOT EXECUTED 10f71a: c3 ret <== NOT EXECUTED 00126b48 <_Chain_Insert>: void _Chain_Insert( Chain_Node *after_node, Chain_Node *node ) { 126b48: 55 push %ebp <== NOT EXECUTED 126b49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126b4b: 53 push %ebx <== NOT EXECUTED 126b4c: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 126b4f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 126b52: 9c pushf <== NOT EXECUTED 126b53: fa cli <== NOT EXECUTED 126b54: 5b pop %ebx <== NOT EXECUTED 126b55: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 126b58: 8b 0a mov (%edx),%ecx <== NOT EXECUTED 126b5a: 89 02 mov %eax,(%edx) <== NOT EXECUTED 126b5c: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 126b5e: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED _Chain_Insert_unprotected( after_node, node ); _ISR_Enable( level ); 126b61: 53 push %ebx <== NOT EXECUTED 126b62: 9d popf <== NOT EXECUTED } 126b63: 5b pop %ebx <== NOT EXECUTED 126b64: c9 leave <== NOT EXECUTED 126b65: c3 ret <== NOT EXECUTED 0010f664 <_Debug_Is_enabled>: */ bool _Debug_Is_enabled( rtems_debug_control level ) { 10f664: 55 push %ebp <== NOT EXECUTED 10f665: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f667: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10f66a: 85 05 80 f8 11 00 test %eax,0x11f880 <== NOT EXECUTED 10f670: 0f 95 c0 setne %al <== NOT EXECUTED return (_Debug_Level & level) ? true : false; } 10f673: c9 leave <== NOT EXECUTED 10f674: c3 ret <== NOT EXECUTED 0010f634 <_Debug_Manager_initialization>: * * _Debug_Manager_initialization */ void _Debug_Manager_initialization( void ) { 10f634: 55 push %ebp <== NOT EXECUTED 10f635: 89 e5 mov %esp,%ebp <== NOT EXECUTED void rtems_debug_disable ( rtems_debug_control to_be_disabled ) { _Debug_Level &= ~to_be_disabled; 10f637: c7 05 80 f8 11 00 00 movl $0x0,0x11f880 <== NOT EXECUTED 10f63e: 00 00 00 <== NOT EXECUTED */ void _Debug_Manager_initialization( void ) { rtems_debug_disable( RTEMS_DEBUG_ALL_MASK ); } 10f641: c9 leave <== NOT EXECUTED 10f642: c3 ret <== NOT EXECUTED 0010f2b4 <_Dual_ported_memory_Manager_initialization>: */ void _Dual_ported_memory_Manager_initialization( uint32_t maximum_ports ) { 10f2b4: 55 push %ebp <== NOT EXECUTED 10f2b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f2b7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f2ba: 6a 04 push $0x4 <== NOT EXECUTED 10f2bc: 6a 00 push $0x0 <== NOT EXECUTED 10f2be: 6a 1c push $0x1c <== NOT EXECUTED 10f2c0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f2c3: 6a 07 push $0x7 <== NOT EXECUTED 10f2c5: 6a 02 push $0x2 <== NOT EXECUTED 10f2c7: 68 80 02 12 00 push $0x120280 <== NOT EXECUTED 10f2cc: e8 9b c8 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10f2d1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10f2d4: c9 leave <== NOT EXECUTED 10f2d5: c3 ret <== NOT EXECUTED 0010f2d8 <_Event_Manager_initialization>: * * This routine performs the initialization necessary for this manager. */ void _Event_Manager_initialization( void ) { 10f2d8: 55 push %ebp <== NOT EXECUTED 10f2d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10f2db: c7 05 80 01 12 00 00 movl $0x0,0x120180 <== NOT EXECUTED 10f2e2: 00 00 00 <== NOT EXECUTED */ #if defined(RTEMS_MULTIPROCESSING) _MPCI_Register_packet_processor( MP_PACKET_EVENT, _Event_MP_Process_packet ); #endif } 10f2e5: c9 leave <== NOT EXECUTED 10f2e6: 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 7c f8 11 00 mov 0x11f87c,%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 80 01 12 00 01 movl $0x1,0x120180 <== 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 26 2e 00 00 call 10cc00 <_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 80 01 12 00 mov 0x120180,%eax <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 109de2: c7 05 80 01 12 00 00 movl $0x0,0x120180 <== 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 1b 20 00 00 jmp 10be24 <_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 9c f8 11 00 push $0x11f89c <== NOT EXECUTED 109e79: e8 de 33 00 00 call 10d25c <_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 58 f8 11 00 mov 0x11f858,%eax <== NOT EXECUTED 109f09: 85 c0 test %eax,%eax <== NOT EXECUTED 109f0b: 74 0c je 109f19 <_Event_Surrender+0x3d> <== NOT EXECUTED 109f0d: 3b 1d 7c f8 11 00 cmp 0x11f87c,%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 3d 20 00 00 call 10bfa4 <_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 f5 33 00 00 call 10d38c <_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 00 20 00 00 call 10bfa4 <_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 80 01 12 00 mov 0x120180,%eax <== NOT EXECUTED 109fb1: 48 dec %eax <== NOT EXECUTED 109fb2: 74 0e je 109fc2 <_Event_Surrender+0xe6> <== NOT EXECUTED 109fb4: a1 80 01 12 00 mov 0x120180,%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 80 01 12 00 03 movl $0x3,0x120180 <== 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 6a 23 00 00 call 10c370 <_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 7c f8 11 00 cmp 0x11f87c,%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 62 1f 00 00 call 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 10a042: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10a047: 48 dec %eax <== NOT EXECUTED 10a048: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== 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 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10a059: 48 dec %eax <== NOT EXECUTED 10a05a: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== 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 80 01 12 00 mov 0x120180,%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 80 01 12 00 02 movl $0x2,0x120180 <== NOT EXECUTED 10a075: 00 00 00 <== NOT EXECUTED 10a078: eb b1 jmp 10a02b <_Event_Timeout+0x37> <== NOT EXECUTED 0010aa24 <_Extension_Manager_initialization>: */ void _Extension_Manager_initialization( uint32_t maximum_extensions ) { 10aa24: 55 push %ebp <== NOT EXECUTED 10aa25: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa27: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10aa2a: 6a 04 push $0x4 <== NOT EXECUTED 10aa2c: 6a 00 push $0x0 <== NOT EXECUTED 10aa2e: 6a 44 push $0x44 <== NOT EXECUTED 10aa30: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10aa33: 6a 09 push $0x9 <== NOT EXECUTED 10aa35: 6a 02 push $0x2 <== NOT EXECUTED 10aa37: 68 e0 01 12 00 push $0x1201e0 <== NOT EXECUTED 10aa3c: e8 2b 11 00 00 call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10aa41: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , false, /* true if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10aa44: c9 leave <== NOT EXECUTED 10aa45: c3 ret <== NOT EXECUTED 0010f93c <_Heap_Allocate>: void *_Heap_Allocate( Heap_Control *the_heap, size_t size ) { 10f93c: 55 push %ebp <== NOT EXECUTED 10f93d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f93f: 57 push %edi <== NOT EXECUTED 10f940: 56 push %esi <== NOT EXECUTED 10f941: 53 push %ebx <== NOT EXECUTED 10f942: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10f945: 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 = 10f948: ff 77 14 pushl 0x14(%edi) <== NOT EXECUTED 10f94b: ff 77 10 pushl 0x10(%edi) <== NOT EXECUTED 10f94e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10f951: e8 72 bb ff ff call 10b4c8 <_Heap_Calc_block_size> <== NOT EXECUTED _Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size); if(the_size == 0) 10f956: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f959: 85 c0 test %eax,%eax <== NOT EXECUTED 10f95b: 74 3b je 10f998 <_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( 10f95d: 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; 10f960: 39 df cmp %ebx,%edi <== NOT EXECUTED 10f962: 74 34 je 10f998 <_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) { 10f964: 3b 43 04 cmp 0x4(%ebx),%eax <== NOT EXECUTED 10f967: 76 5c jbe 10f9c5 <_Heap_Allocate+0x89> <== NOT EXECUTED stats->allocs += 1; stats->searches += search_count + 1; _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; 10f969: 31 f6 xor %esi,%esi <== NOT EXECUTED 10f96b: eb 08 jmp 10f975 <_Heap_Allocate+0x39> <== NOT EXECUTED 10f96d: 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) { 10f970: 3b 43 04 cmp 0x4(%ebx),%eax <== NOT EXECUTED 10f973: 76 2f jbe 10f9a4 <_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) 10f975: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED 10f978: 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; 10f979: 39 df cmp %ebx,%edi <== NOT EXECUTED 10f97b: 75 f3 jne 10f970 <_Heap_Allocate+0x34> <== NOT EXECUTED 10f97d: 89 75 f0 mov %esi,-0x10(%ebp) <== NOT EXECUTED 10f980: 31 d2 xor %edx,%edx <== NOT EXECUTED _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; } } if(stats->max_search < search_count) 10f982: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10f985: 39 47 44 cmp %eax,0x44(%edi) <== NOT EXECUTED 10f988: 73 03 jae 10f98d <_Heap_Allocate+0x51> <== NOT EXECUTED stats->max_search = search_count; 10f98a: 89 47 44 mov %eax,0x44(%edi) <== NOT EXECUTED return ptr; } 10f98d: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f98f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f992: 5b pop %ebx <== NOT EXECUTED 10f993: 5e pop %esi <== NOT EXECUTED 10f994: 5f pop %edi <== NOT EXECUTED 10f995: c9 leave <== NOT EXECUTED 10f996: c3 ret <== NOT EXECUTED 10f997: 90 nop <== NOT EXECUTED break; } } if(stats->max_search < search_count) stats->max_search = search_count; 10f998: 31 d2 xor %edx,%edx <== NOT EXECUTED return ptr; } 10f99a: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f99c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f99f: 5b pop %ebx <== NOT EXECUTED 10f9a0: 5e pop %esi <== NOT EXECUTED 10f9a1: 5f pop %edi <== NOT EXECUTED 10f9a2: c9 leave <== NOT EXECUTED 10f9a3: 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) { 10f9a4: 89 75 f0 mov %esi,-0x10(%ebp) <== NOT EXECUTED (void)_Heap_Block_allocate(the_heap, the_block, the_size ); 10f9a7: 52 push %edx <== NOT EXECUTED 10f9a8: 50 push %eax <== NOT EXECUTED 10f9a9: 53 push %ebx <== NOT EXECUTED 10f9aa: 57 push %edi <== NOT EXECUTED 10f9ab: e8 4c bb ff ff call 10b4fc <_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 10f9b0: 8d 53 08 lea 0x8(%ebx),%edx <== NOT EXECUTED ptr = _Heap_User_area(the_block); stats->allocs += 1; 10f9b3: ff 47 48 incl 0x48(%edi) <== NOT EXECUTED stats->searches += search_count + 1; 10f9b6: 8b 47 4c mov 0x4c(%edi),%eax <== NOT EXECUTED 10f9b9: 8d 44 06 01 lea 0x1(%esi,%eax,1),%eax <== NOT EXECUTED 10f9bd: 89 47 4c mov %eax,0x4c(%edi) <== NOT EXECUTED 10f9c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f9c3: eb bd jmp 10f982 <_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) { 10f9c5: 31 f6 xor %esi,%esi <== NOT EXECUTED 10f9c7: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED 10f9ce: eb d7 jmp 10f9a7 <_Heap_Allocate+0x6b> <== NOT EXECUTED 0010ccc0 <_Heap_Allocate_aligned>: void *_Heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ) { 10ccc0: 55 push %ebp <== NOT EXECUTED 10ccc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ccc3: 57 push %edi <== NOT EXECUTED 10ccc4: 56 push %esi <== NOT EXECUTED 10ccc5: 53 push %ebx <== NOT EXECUTED 10ccc6: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 10ccc9: 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; 10cccc: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10cccf: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 10ccd2: 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; 10ccd5: 8d 48 fc lea -0x4(%eax),%ecx <== NOT EXECUTED 10ccd8: 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); 10ccdb: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10ccde: ff 77 14 pushl 0x14(%edi) <== NOT EXECUTED 10cce1: 52 push %edx <== NOT EXECUTED 10cce2: 50 push %eax <== NOT EXECUTED 10cce3: e8 8c 04 00 00 call 10d174 <_Heap_Calc_block_size> <== NOT EXECUTED 10cce8: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED if(the_size == 0) 10cceb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ccee: 85 c0 test %eax,%eax <== NOT EXECUTED 10ccf0: 0f 84 1a 01 00 00 je 10ce10 <_Heap_Allocate_aligned+0x150> <== NOT EXECUTED return NULL; if(alignment == 0) 10ccf6: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10ccf9: 85 c0 test %eax,%eax <== NOT EXECUTED 10ccfb: 0f 84 03 01 00 00 je 10ce04 <_Heap_Allocate_aligned+0x144> <== NOT EXECUTED ) { return ( the_thread == _Thread_Heir ); } /** 10cd01: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cd04: 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; 10cd07: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10cd09: 0f 84 01 01 00 00 je 10ce10 <_Heap_Allocate_aligned+0x150> <== NOT EXECUTED 10cd0f: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED 10cd16: eb 17 jmp 10cd2f <_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) { 10cd18: 89 f2 mov %esi,%edx <== NOT EXECUTED aligned_user_addr = 0; } } } if(aligned_user_addr) { 10cd1a: 85 ff test %edi,%edi <== NOT EXECUTED 10cd1c: 75 7a jne 10cd98 <_Heap_Allocate_aligned+0xd8> <== NOT EXECUTED 10cd1e: 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) 10cd20: 8b 49 08 mov 0x8(%ecx),%ecx <== NOT EXECUTED 10cd23: 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; 10cd26: 39 4d 08 cmp %ecx,0x8(%ebp) <== NOT EXECUTED 10cd29: 0f 84 ed 00 00 00 je 10ce1c <_Heap_Allocate_aligned+0x15c> <== NOT EXECUTED 10cd2f: 8b 59 04 mov 0x4(%ecx),%ebx <== NOT EXECUTED 10cd32: 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. */ 10cd35: 39 5d e4 cmp %ebx,-0x1c(%ebp) <== NOT EXECUTED 10cd38: 77 e6 ja 10cd20 <_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)); 10cd3a: 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; 10cd3d: 8d 14 19 lea (%ecx,%ebx,1),%edx <== NOT EXECUTED 10cd40: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED aligned_user_addr = block_end - end_to_user_offs; 10cd43: 89 d7 mov %edx,%edi <== NOT EXECUTED 10cd45: 2b 7d e0 sub -0x20(%ebp),%edi <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Dispatch_initialization( void ) { _Thread_Dispatch_disable_level = 1; } 10cd48: 89 f8 mov %edi,%eax <== NOT EXECUTED 10cd4a: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cd4c: f7 75 10 divl 0x10(%ebp) <== NOT EXECUTED 10cd4f: 29 d7 sub %edx,%edi <== NOT EXECUTED 10cd51: 89 f8 mov %edi,%eax <== NOT EXECUTED 10cd53: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cd55: f7 75 dc divl -0x24(%ebp) <== NOT EXECUTED 10cd58: 89 f8 mov %edi,%eax <== NOT EXECUTED 10cd5a: 29 d0 sub %edx,%eax <== NOT EXECUTED 10cd5c: 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) { 10cd5e: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10cd60: 77 be ja 10cd20 <_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) { 10cd62: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cd65: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10cd68: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 10cd6b: 89 d0 mov %edx,%eax <== NOT EXECUTED 10cd6d: 29 f0 sub %esi,%eax <== NOT EXECUTED 10cd6f: 3b 45 ec cmp -0x14(%ebp),%eax <== NOT EXECUTED 10cd72: 73 a6 jae 10cd1a <_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) { 10cd74: 89 f8 mov %edi,%eax <== NOT EXECUTED 10cd76: 29 f0 sub %esi,%eax <== NOT EXECUTED 10cd78: 39 45 dc cmp %eax,-0x24(%ebp) <== NOT EXECUTED 10cd7b: 77 9b ja 10cd18 <_Heap_Allocate_aligned+0x58> <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); } /** 10cd7d: 89 f0 mov %esi,%eax <== NOT EXECUTED 10cd7f: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cd81: f7 75 10 divl 0x10(%ebp) <== NOT EXECUTED * This function returns TRUE if dispatching is disabled, and FALSE 10cd84: 85 d2 test %edx,%edx <== NOT EXECUTED 10cd86: 75 6c jne 10cdf4 <_Heap_Allocate_aligned+0x134> <== NOT EXECUTED 10cd88: 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) { 10cd8a: 39 55 dc cmp %edx,-0x24(%ebp) <== NOT EXECUTED 10cd8d: 76 91 jbe 10cd20 <_Heap_Allocate_aligned+0x60> <== NOT EXECUTED 10cd8f: 89 f2 mov %esi,%edx <== NOT EXECUTED 10cd91: 89 c7 mov %eax,%edi <== NOT EXECUTED aligned_user_addr = 0; } } } if(aligned_user_addr) { 10cd93: 85 ff test %edi,%edi <== NOT EXECUTED 10cd95: 74 89 je 10cd20 <_Heap_Allocate_aligned+0x60> <== NOT EXECUTED 10cd97: 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; 10cd98: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 10cd9b: 83 c6 08 add $0x8,%esi <== NOT EXECUTED 10cd9e: 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; 10cda0: 89 da mov %ebx,%edx <== NOT EXECUTED 10cda2: 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) { 10cda4: 3b 55 ec cmp -0x14(%ebp),%edx <== NOT EXECUTED 10cda7: 0f 82 87 00 00 00 jb 10ce34 <_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; 10cdad: 89 d0 mov %edx,%eax <== NOT EXECUTED 10cdaf: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10cdb2: 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 ); 10cdb5: 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 10cdb8: 89 c1 mov %eax,%ecx <== NOT EXECUTED the_block = _Heap_Block_at(the_block, the_rest); the_block->prev_size = the_rest; 10cdba: 89 10 mov %edx,(%eax) <== NOT EXECUTED the_block->size = alloc_size; 10cdbc: 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; 10cdbf: 83 4c 31 04 01 orl $0x1,0x4(%ecx,%esi,1) <== NOT EXECUTED /* Update statistics */ stats->free_size -= alloc_size; 10cdc4: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10cdc7: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10cdca: 29 f0 sub %esi,%eax <== NOT EXECUTED 10cdcc: 89 42 30 mov %eax,0x30(%edx) <== NOT EXECUTED if(stats->min_free_size > stats->free_size) 10cdcf: 3b 42 34 cmp 0x34(%edx),%eax <== NOT EXECUTED 10cdd2: 73 03 jae 10cdd7 <_Heap_Allocate_aligned+0x117> <== NOT EXECUTED stats->min_free_size = stats->free_size; 10cdd4: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED stats->used_blocks += 1; 10cdd7: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10cdda: 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; 10cddd: 8b 41 4c mov 0x4c(%ecx),%eax <== NOT EXECUTED 10cde0: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10cde3: 8d 44 02 01 lea 0x1(%edx,%eax,1),%eax <== NOT EXECUTED 10cde7: 89 41 4c mov %eax,0x4c(%ecx) <== NOT EXECUTED stats->allocs += 1; 10cdea: 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; 10cded: 89 f8 mov %edi,%eax <== NOT EXECUTED 10cdef: eb 2d jmp 10ce1e <_Heap_Allocate_aligned+0x15e> <== NOT EXECUTED 10cdf1: 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 10cdf4: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10cdf7: 8d 04 3e lea (%esi,%edi,1),%eax <== NOT EXECUTED 10cdfa: 29 d0 sub %edx,%eax <== NOT EXECUTED 10cdfc: 89 c2 mov %eax,%edx <== NOT EXECUTED 10cdfe: 29 f2 sub %esi,%edx <== NOT EXECUTED 10ce00: eb 88 jmp 10cd8a <_Heap_Allocate_aligned+0xca> <== NOT EXECUTED 10ce02: 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) 10ce04: c7 45 10 04 00 00 00 movl $0x4,0x10(%ebp) <== NOT EXECUTED 10ce0b: e9 f1 fe ff ff jmp 10cd01 <_Heap_Allocate_aligned+0x41> <== NOT EXECUTED } } } if(stats->max_search < search_count) stats->max_search = search_count; 10ce10: 31 c0 xor %eax,%eax <== NOT EXECUTED return user_ptr; } 10ce12: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ce15: 5b pop %ebx <== NOT EXECUTED 10ce16: 5e pop %esi <== NOT EXECUTED 10ce17: 5f pop %edi <== NOT EXECUTED 10ce18: c9 leave <== NOT EXECUTED 10ce19: c3 ret <== NOT EXECUTED 10ce1a: 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; 10ce1c: 31 c0 xor %eax,%eax <== NOT EXECUTED } } } } if(stats->max_search < search_count) 10ce1e: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10ce21: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10ce24: 39 4f 44 cmp %ecx,0x44(%edi) <== NOT EXECUTED 10ce27: 73 e9 jae 10ce12 <_Heap_Allocate_aligned+0x152> <== NOT EXECUTED stats->max_search = search_count; 10ce29: 89 4f 44 mov %ecx,0x44(%edi) <== NOT EXECUTED return user_ptr; } 10ce2c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ce2f: 5b pop %ebx <== NOT EXECUTED 10ce30: 5e pop %esi <== NOT EXECUTED 10ce31: 5f pop %edi <== NOT EXECUTED 10ce32: c9 leave <== NOT EXECUTED 10ce33: 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 ) { 10ce34: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) 10ce37: 8b 41 0c mov 0xc(%ecx),%eax <== NOT EXECUTED if ( _Thread_Executing->fp_context != NULL ) 10ce3a: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED _Context_Restore_fp( &_Thread_Executing->fp_context ); 10ce3d: 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; 10ce40: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ce43: ff 48 38 decl 0x38(%eax) <== NOT EXECUTED 10ce46: 89 de mov %ebx,%esi <== NOT EXECUTED 10ce48: e9 72 ff ff ff jmp 10cdbf <_Heap_Allocate_aligned+0xff> <== NOT EXECUTED 0010b4fc <_Heap_Block_allocate>: uint32_t _Heap_Block_allocate( Heap_Control* the_heap, Heap_Block* the_block, uint32_t alloc_size ) { 10b4fc: 55 push %ebp <== NOT EXECUTED 10b4fd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4ff: 57 push %edi <== NOT EXECUTED 10b500: 56 push %esi <== NOT EXECUTED 10b501: 53 push %ebx <== NOT EXECUTED 10b502: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10b505: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10b508: 8b 4e 04 mov 0x4(%esi),%ecx <== NOT EXECUTED 10b50b: 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; 10b50e: 89 cb mov %ecx,%ebx <== NOT EXECUTED 10b510: 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) { 10b512: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b515: 3b 58 14 cmp 0x14(%eax),%ebx <== NOT EXECUTED 10b518: 72 4a jb 10b564 <_Heap_Block_allocate+0x68> <== NOT EXECUTED 10b51a: 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 */ 10b51d: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED bool _Protected_heap_Get_block_size( 10b520: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size 10b523: 89 4a 08 mov %ecx,0x8(%edx) <== NOT EXECUTED ); 10b526: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED 10b529: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED 10b52c: 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; 10b52f: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b531: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10b534: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED next_block->size = the_rest | HEAP_PREV_USED; 10b537: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b539: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10b53c: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED _Heap_Block_at(next_block, the_rest)->prev_size = the_rest; 10b53f: 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; 10b542: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b545: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10b548: 29 f8 sub %edi,%eax <== NOT EXECUTED 10b54a: 89 42 30 mov %eax,0x30(%edx) <== NOT EXECUTED if(stats->min_free_size > stats->free_size) 10b54d: 3b 42 34 cmp 0x34(%edx),%eax <== NOT EXECUTED 10b550: 73 03 jae 10b555 <_Heap_Block_allocate+0x59> <== NOT EXECUTED stats->min_free_size = stats->free_size; 10b552: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED stats->used_blocks += 1; 10b555: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b558: ff 40 40 incl 0x40(%eax) <== NOT EXECUTED return alloc_size; } 10b55b: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b55d: 5b pop %ebx <== NOT EXECUTED 10b55e: 5e pop %esi <== NOT EXECUTED 10b55f: 5f pop %edi <== NOT EXECUTED 10b560: c9 leave <== NOT EXECUTED 10b561: c3 ret <== NOT EXECUTED 10b562: 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 10b564: 8b 56 08 mov 0x8(%esi),%edx <== NOT EXECUTED * @param[in] size is the amount of memory to allocate in bytes 10b567: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED * @param[in] alignment the required alignment 10b56a: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10b56d: 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; 10b570: 83 4c 0e 04 01 orl $0x1,0x4(%esi,%ecx,1) <== NOT EXECUTED stats->free_blocks -= 1; 10b575: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b578: ff 4a 38 decl 0x38(%edx) <== NOT EXECUTED 10b57b: 89 cf mov %ecx,%edi <== NOT EXECUTED 10b57d: eb c3 jmp 10b542 <_Heap_Block_allocate+0x46> <== NOT EXECUTED 0010b4c8 <_Heap_Calc_block_size>: */ size_t _Heap_Calc_block_size( size_t size, uint32_t page_size, uint32_t min_size) { 10b4c8: 55 push %ebp <== NOT EXECUTED 10b4c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4cb: 53 push %ebx <== NOT EXECUTED 10b4cc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b4cf: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED uint32_t block_size = size + HEAP_BLOCK_USED_OVERHEAD; 10b4d2: 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 10b4d5: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b4d7: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b4d9: f7 75 0c divl 0xc(%ebp) <== NOT EXECUTED */ 10b4dc: 85 d2 test %edx,%edx <== NOT EXECUTED 10b4de: 74 05 je 10b4e5 <_Heap_Calc_block_size+0x1d> <== NOT EXECUTED 10b4e0: 03 5d 0c add 0xc(%ebp),%ebx <== NOT EXECUTED 10b4e3: 29 d3 sub %edx,%ebx <== NOT EXECUTED 10b4e5: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b4e7: 3b 5d 10 cmp 0x10(%ebp),%ebx <== NOT EXECUTED 10b4ea: 73 03 jae 10b4ef <_Heap_Calc_block_size+0x27> <== NOT EXECUTED 10b4ec: 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; 10b4ef: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10b4f1: 72 02 jb 10b4f5 <_Heap_Calc_block_size+0x2d> <== NOT EXECUTED 10b4f3: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10b4f5: 5a pop %edx <== NOT EXECUTED 10b4f6: 5b pop %ebx <== NOT EXECUTED 10b4f7: c9 leave <== NOT EXECUTED 10b4f8: c3 ret <== NOT EXECUTED 00111ad4 <_Heap_Extend>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t *amount_extended ) { 111ad4: 55 push %ebp <== NOT EXECUTED 111ad5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111ad7: 56 push %esi <== NOT EXECUTED 111ad8: 53 push %ebx <== NOT EXECUTED 111ad9: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 111adc: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 111adf: 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 */ 111ae2: 39 41 18 cmp %eax,0x18(%ecx) <== NOT EXECUTED 111ae5: 76 15 jbe 111afc <_Heap_Extend+0x28> <== NOT EXECUTED 111ae7: 8b 51 1c mov 0x1c(%ecx),%edx <== NOT EXECUTED starting_address < the_heap->end ) return HEAP_EXTEND_ERROR; if ( starting_address != the_heap->end ) 111aea: 39 d0 cmp %edx,%eax <== NOT EXECUTED 111aec: 74 22 je 111b10 <_Heap_Extend+0x3c> <== NOT EXECUTED 111aee: 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; } 111af3: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111af6: 5b pop %ebx <== NOT EXECUTED 111af7: 5e pop %esi <== NOT EXECUTED 111af8: c9 leave <== NOT EXECUTED 111af9: c3 ret <== NOT EXECUTED 111afa: 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 */ 111afc: 8b 51 1c mov 0x1c(%ecx),%edx <== NOT EXECUTED 111aff: 39 d0 cmp %edx,%eax <== NOT EXECUTED 111b01: 73 e7 jae 111aea <_Heap_Extend+0x16> <== NOT EXECUTED 111b03: 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; } 111b08: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111b0b: 5b pop %ebx <== NOT EXECUTED 111b0c: 5e pop %esi <== NOT EXECUTED 111b0d: c9 leave <== NOT EXECUTED 111b0e: c3 ret <== NOT EXECUTED 111b0f: 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; 111b10: 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 ); 111b13: 03 45 10 add 0x10(%ebp),%eax <== NOT EXECUTED the_heap->end = _Addresses_Add_offset( the_heap->end, size ); 111b16: 89 41 1c mov %eax,0x1c(%ecx) <== NOT EXECUTED the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD; 111b19: 29 d8 sub %ebx,%eax <== NOT EXECUTED 111b1b: 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) || \ 111b1e: 89 f0 mov %esi,%eax <== NOT EXECUTED 111b20: 31 d2 xor %edx,%edx <== NOT EXECUTED 111b22: f7 71 10 divl 0x10(%ecx) <== NOT EXECUTED 111b25: 29 d6 sub %edx,%esi <== NOT EXECUTED 111b27: 89 f2 mov %esi,%edx <== NOT EXECUTED _Heap_Align_down( &the_size, the_heap->page_size ); *amount_extended = size; 111b29: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 111b2c: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 111b2f: 89 06 mov %eax,(%esi) <== NOT EXECUTED if( the_size < the_heap->min_block_size ) 111b31: 39 51 14 cmp %edx,0x14(%ecx) <== NOT EXECUTED 111b34: 76 06 jbe 111b3c <_Heap_Extend+0x68> <== NOT EXECUTED 111b36: 31 c0 xor %eax,%eax <== NOT EXECUTED 111b38: eb b9 jmp 111af3 <_Heap_Extend+0x1f> <== NOT EXECUTED 111b3a: 66 90 xchg %ax,%ax <== NOT EXECUTED return HEAP_EXTEND_SUCCESSFUL; old_final->size = the_size | (old_final->size & HEAP_PREV_USED); 111b3c: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 111b3f: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 111b42: 09 d0 or %edx,%eax <== NOT EXECUTED 111b44: 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 111b47: 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; 111b4a: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) <== NOT EXECUTED the_heap->final = new_final; 111b51: 89 41 24 mov %eax,0x24(%ecx) <== NOT EXECUTED stats->size += size; 111b54: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 111b57: 01 51 2c add %edx,0x2c(%ecx) <== NOT EXECUTED stats->used_blocks += 1; 111b5a: ff 41 40 incl 0x40(%ecx) <== NOT EXECUTED stats->frees -= 1; /* Don't count subsequent call as actual free() */ 111b5d: ff 49 50 decl 0x50(%ecx) <== NOT EXECUTED _Heap_Free( the_heap, _Heap_User_area( old_final ) ); 111b60: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111b63: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 111b66: 50 push %eax <== NOT EXECUTED 111b67: 51 push %ecx <== NOT EXECUTED 111b68: e8 77 b3 ff ff call 10cee4 <_Heap_Free> <== NOT EXECUTED 111b6d: 31 c0 xor %eax,%eax <== NOT EXECUTED 111b6f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111b72: e9 7c ff ff ff jmp 111af3 <_Heap_Extend+0x1f> <== NOT EXECUTED 0010f9d0 <_Heap_Free>: bool _Heap_Free( Heap_Control *the_heap, void *starting_address ) { 10f9d0: 55 push %ebp <== NOT EXECUTED 10f9d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f9d3: 57 push %edi <== NOT EXECUTED 10f9d4: 56 push %esi <== NOT EXECUTED 10f9d5: 53 push %ebx <== NOT EXECUTED 10f9d6: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10f9d9: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10f9dc: 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( 10f9df: 8b 77 24 mov 0x24(%edi),%esi <== NOT EXECUTED 10f9e2: 8b 4f 20 mov 0x20(%edi),%ecx <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10f9e5: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10f9e7: 77 04 ja 10f9ed <_Heap_Free+0x1d> <== NOT EXECUTED 10f9e9: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10f9eb: 73 0b jae 10f9f8 <_Heap_Free+0x28> <== NOT EXECUTED stats->used_blocks -= 1; stats->free_size += the_size; stats->frees += 1; return( TRUE ); 10f9ed: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10f9ef: 83 c4 18 add $0x18,%esp <== NOT EXECUTED 10f9f2: 5b pop %ebx <== NOT EXECUTED 10f9f3: 5e pop %esi <== NOT EXECUTED 10f9f4: 5f pop %edi <== NOT EXECUTED 10f9f5: c9 leave <== NOT EXECUTED 10f9f6: c3 ret <== NOT EXECUTED 10f9f7: 90 nop <== NOT EXECUTED 10f9f8: 8d 58 f8 lea -0x8(%eax),%ebx <== NOT EXECUTED 10f9fb: 31 d2 xor %edx,%edx <== NOT EXECUTED 10f9fd: f7 77 10 divl 0x10(%edi) <== NOT EXECUTED 10fa00: 29 d3 sub %edx,%ebx <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10fa02: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 10fa04: 77 e7 ja 10f9ed <_Heap_Free+0x1d> <== NOT EXECUTED 10fa06: 39 de cmp %ebx,%esi <== NOT EXECUTED 10fa08: 72 e3 jb 10f9ed <_Heap_Free+0x1d> <== NOT EXECUTED 10fa0a: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10fa0d: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED 10fa10: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 10fa13: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 10fa16: 01 d8 add %ebx,%eax <== NOT EXECUTED 10fa18: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10fa1b: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10fa1d: 77 ce ja 10f9ed <_Heap_Free+0x1d> <== NOT EXECUTED 10fa1f: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10fa21: 72 ca jb 10f9ed <_Heap_Free+0x1d> <== NOT EXECUTED 10fa23: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 10fa26: 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 ) ) { 10fa29: f6 c2 01 test $0x1,%dl <== NOT EXECUTED 10fa2c: 74 bf je 10f9ed <_Heap_Free+0x1d> <== NOT EXECUTED 10fa2e: 83 e2 fe and $0xfffffffe,%edx <== NOT EXECUTED 10fa31: 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 && 10fa34: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10fa36: 76 74 jbe 10faac <_Heap_Free+0xdc> <== NOT EXECUTED 10fa38: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10fa3b: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10fa3e: 8b 44 02 04 mov 0x4(%edx,%eax,1),%eax <== NOT EXECUTED 10fa42: 83 f0 01 xor $0x1,%eax <== NOT EXECUTED 10fa45: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10fa48: 8a 45 e0 mov -0x20(%ebp),%al <== NOT EXECUTED 10fa4b: 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 ) ) { 10fa4e: f6 45 dc 01 testb $0x1,-0x24(%ebp) <== NOT EXECUTED 10fa52: 75 5c jne 10fab0 <_Heap_Free+0xe0> <== NOT EXECUTED uint32_t const prev_size = the_block->prev_size; 10fa54: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10fa56: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 10fa59: 29 d3 sub %edx,%ebx <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10fa5b: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 10fa5d: 77 8e ja 10f9ed <_Heap_Free+0x1d> <== NOT EXECUTED 10fa5f: 39 de cmp %ebx,%esi <== NOT EXECUTED 10fa61: 72 8a jb 10f9ed <_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) ) { 10fa63: f6 43 04 01 testb $0x1,0x4(%ebx) <== NOT EXECUTED 10fa67: 74 84 je 10f9ed <_Heap_Free+0x1d> <== NOT EXECUTED _HAssert( FALSE ); return( FALSE ); } if ( next_is_free ) { /* coalesce both */ 10fa69: 84 c0 test %al,%al <== NOT EXECUTED 10fa6b: 0f 84 a0 00 00 00 je 10fb11 <_Heap_Free+0x141> <== NOT EXECUTED uint32_t const size = the_size + prev_size + next_size; 10fa71: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10fa74: 03 55 ec add -0x14(%ebp),%edx <== NOT EXECUTED 10fa77: 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 10fa7a: 8b 75 e4 mov -0x1c(%ebp),%esi <== NOT EXECUTED 10fa7d: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED * @param[in] size is the amount of memory to allocate in bytes 10fa80: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED * @param[in] alignment the required alignment 10fa83: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10fa86: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED _Heap_Block_remove( next_block ); stats->free_blocks -= 1; 10fa89: ff 4f 38 decl 0x38(%edi) <== NOT EXECUTED prev_block->size = size | HEAP_PREV_USED; 10fa8c: 89 d0 mov %edx,%eax <== NOT EXECUTED 10fa8e: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10fa91: 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; 10fa94: 89 14 13 mov %edx,(%ebx,%edx,1) <== NOT EXECUTED 10fa97: 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; 10fa98: ff 4f 40 decl 0x40(%edi) <== NOT EXECUTED stats->free_size += the_size; 10fa9b: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 10fa9e: 01 77 30 add %esi,0x30(%edi) <== NOT EXECUTED stats->frees += 1; 10faa1: ff 47 50 incl 0x50(%edi) <== NOT EXECUTED 10faa4: b0 01 mov $0x1,%al <== NOT EXECUTED 10faa6: e9 44 ff ff ff jmp 10f9ef <_Heap_Free+0x1f> <== NOT EXECUTED 10faab: 90 nop <== NOT EXECUTED _HAssert( FALSE ); return( FALSE ); } next_size = _Heap_Block_size( next_block ); next_is_free = next_block < the_heap->final && 10faac: 31 c0 xor %eax,%eax <== NOT EXECUTED 10faae: eb 9e jmp 10fa4e <_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 */ 10fab0: 84 c0 test %al,%al <== NOT EXECUTED 10fab2: 74 28 je 10fadc <_Heap_Free+0x10c> <== NOT EXECUTED uint32_t const size = the_size + next_size; 10fab4: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10fab7: 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 */ 10faba: 8b 75 e4 mov -0x1c(%ebp),%esi <== NOT EXECUTED 10fabd: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED bool _Protected_heap_Get_block_size( 10fac0: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size 10fac3: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED ); 10fac6: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED 10fac9: 89 58 08 mov %ebx,0x8(%eax) <== NOT EXECUTED 10facc: 89 59 0c mov %ebx,0xc(%ecx) <== NOT EXECUTED _Heap_Block_replace( next_block, the_block ); the_block->size = size | HEAP_PREV_USED; 10facf: 89 d0 mov %edx,%eax <== NOT EXECUTED 10fad1: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10fad4: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block = _Heap_Block_at( the_block, size ); next_block->prev_size = size; 10fad7: 89 14 13 mov %edx,(%ebx,%edx,1) <== NOT EXECUTED 10fada: eb bc jmp 10fa98 <_Heap_Free+0xc8> <== NOT EXECUTED bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ); 10fadc: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED /** 10fadf: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED * This routine returns the block of memory which begins 10fae2: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10fae5: 89 5f 08 mov %ebx,0x8(%edi) <== NOT EXECUTED 10fae8: 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; 10faeb: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10faee: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10faf1: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block->size &= ~HEAP_PREV_USED; 10faf4: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10faf7: 83 60 04 fe andl $0xfffffffe,0x4(%eax) <== NOT EXECUTED next_block->prev_size = the_size; 10fafb: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10fafe: 89 10 mov %edx,(%eax) <== NOT EXECUTED stats->free_blocks += 1; 10fb00: 8b 47 38 mov 0x38(%edi),%eax <== NOT EXECUTED 10fb03: 40 inc %eax <== NOT EXECUTED 10fb04: 89 47 38 mov %eax,0x38(%edi) <== NOT EXECUTED if ( stats->max_free_blocks < stats->free_blocks ) 10fb07: 3b 47 3c cmp 0x3c(%edi),%eax <== NOT EXECUTED 10fb0a: 76 8c jbe 10fa98 <_Heap_Free+0xc8> <== NOT EXECUTED stats->max_free_blocks = stats->free_blocks; 10fb0c: 89 47 3c mov %eax,0x3c(%edi) <== NOT EXECUTED 10fb0f: eb 87 jmp 10fa98 <_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; 10fb11: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10fb14: 03 55 f0 add -0x10(%ebp),%edx <== NOT EXECUTED prev_block->size = size | HEAP_PREV_USED; 10fb17: 89 d0 mov %edx,%eax <== NOT EXECUTED 10fb19: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10fb1c: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block->size &= ~HEAP_PREV_USED; 10fb1f: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10fb22: 83 60 04 fe andl $0xfffffffe,0x4(%eax) <== NOT EXECUTED next_block->prev_size = size; 10fb26: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10fb28: e9 6b ff ff ff jmp 10fa98 <_Heap_Free+0xc8> <== NOT EXECUTED 00127034 <_Heap_Get_free_information>: void _Heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 127034: 55 push %ebp <== NOT EXECUTED 127035: 89 e5 mov %esp,%ebp <== NOT EXECUTED 127037: 53 push %ebx <== NOT EXECUTED 127038: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 12703b: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED Heap_Block *the_block; Heap_Block *const tail = _Heap_Tail(the_heap); info->number = 0; 12703e: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED info->largest = 0; 127044: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED info->total = 0; 12704b: 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( 127052: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED for(the_block = _Heap_First(the_heap); the_block != tail; 127055: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 127057: 74 1d je 127076 <_Heap_Get_free_information+0x42> <== NOT EXECUTED 127059: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 12705c: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 12705f: 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++; 127062: ff 01 incl (%ecx) <== NOT EXECUTED info->total += the_size; 127064: 01 41 08 add %eax,0x8(%ecx) <== NOT EXECUTED if ( info->largest < the_size ) 127067: 39 41 04 cmp %eax,0x4(%ecx) <== NOT EXECUTED 12706a: 73 03 jae 12706f <_Heap_Get_free_information+0x3b> <== NOT EXECUTED info->largest = the_size; 12706c: 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) 12706f: 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; 127072: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 127074: 75 e6 jne 12705c <_Heap_Get_free_information+0x28> <== NOT EXECUTED info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 127076: 5b pop %ebx <== NOT EXECUTED 127077: c9 leave <== NOT EXECUTED 127078: c3 ret <== NOT EXECUTED 00130184 <_Heap_Get_information>: Heap_Get_information_status _Heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 130184: 55 push %ebp <== NOT EXECUTED 130185: 89 e5 mov %esp,%ebp <== NOT EXECUTED 130187: 56 push %esi <== NOT EXECUTED 130188: 53 push %ebx <== NOT EXECUTED 130189: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 13018c: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED Heap_Block *the_block = the_heap->start; 13018f: 8b 50 20 mov 0x20(%eax),%edx <== NOT EXECUTED Heap_Block *const end = the_heap->final; 130192: 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; 130195: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED the_info->Free.total = 0; 13019b: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED the_info->Free.largest = 0; 1301a2: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED the_info->Used.number = 0; 1301a9: c7 41 0c 00 00 00 00 movl $0x0,0xc(%ecx) <== NOT EXECUTED the_info->Used.total = 0; 1301b0: c7 41 14 00 00 00 00 movl $0x0,0x14(%ecx) <== NOT EXECUTED the_info->Used.largest = 0; 1301b7: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx) <== NOT EXECUTED while ( the_block != end ) { 1301be: 39 f2 cmp %esi,%edx <== NOT EXECUTED 1301c0: 74 42 je 130204 <_Heap_Get_information+0x80> <== NOT EXECUTED 1301c2: 8b 5a 04 mov 0x4(%edx),%ebx <== NOT EXECUTED 1301c5: eb 13 jmp 1301da <_Heap_Get_information+0x56> <== NOT EXECUTED 1301c7: 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++; 1301c8: ff 41 0c incl 0xc(%ecx) <== NOT EXECUTED the_info->Used.total += the_size; 1301cb: 01 41 14 add %eax,0x14(%ecx) <== NOT EXECUTED if ( the_info->Used.largest < the_size ) 1301ce: 39 41 10 cmp %eax,0x10(%ecx) <== NOT EXECUTED 1301d1: 73 03 jae 1301d6 <_Heap_Get_information+0x52> <== NOT EXECUTED the_info->Used.largest = the_size; 1301d3: 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 ) { 1301d6: 39 d6 cmp %edx,%esi <== NOT EXECUTED 1301d8: 74 2a je 130204 <_Heap_Get_information+0x80> <== NOT EXECUTED 1301da: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1301dc: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 1301df: 01 c2 add %eax,%edx <== NOT EXECUTED 1301e1: 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) ) { 1301e4: f6 c3 01 test $0x1,%bl <== NOT EXECUTED 1301e7: 75 df jne 1301c8 <_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++; 1301e9: ff 01 incl (%ecx) <== NOT EXECUTED the_info->Free.total += the_size; 1301eb: 01 41 08 add %eax,0x8(%ecx) <== NOT EXECUTED if ( the_info->Free.largest < the_size ) 1301ee: 39 41 04 cmp %eax,0x4(%ecx) <== NOT EXECUTED 1301f1: 73 03 jae 1301f6 <_Heap_Get_information+0x72> <== NOT EXECUTED the_info->Free.largest = the_size; 1301f3: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED if ( the_size != next_block->prev_size ) 1301f6: 39 02 cmp %eax,(%edx) <== NOT EXECUTED 1301f8: 74 dc je 1301d6 <_Heap_Get_information+0x52> <== NOT EXECUTED 1301fa: 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; } 1301ff: 5b pop %ebx <== NOT EXECUTED 130200: 5e pop %esi <== NOT EXECUTED 130201: c9 leave <== NOT EXECUTED 130202: c3 ret <== NOT EXECUTED 130203: 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; 130204: 83 41 14 08 addl $0x8,0x14(%ecx) <== NOT EXECUTED 130208: 31 c0 xor %eax,%eax <== NOT EXECUTED return HEAP_GET_INFORMATION_SUCCESSFUL; } 13020a: 5b pop %ebx <== NOT EXECUTED 13020b: 5e pop %esi <== NOT EXECUTED 13020c: c9 leave <== NOT EXECUTED 13020d: c3 ret <== NOT EXECUTED 0010b398 <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 10b398: 55 push %ebp <== NOT EXECUTED 10b399: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b39b: 57 push %edi <== NOT EXECUTED 10b39c: 56 push %esi <== NOT EXECUTED 10b39d: 53 push %ebx <== NOT EXECUTED 10b39e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b3a1: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b3a4: 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) 10b3a7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b3a9: 0f 85 fd 00 00 00 jne 10b4ac <_Heap_Initialize+0x114> <== NOT EXECUTED 10b3af: b1 04 mov $0x4,%cl <== NOT EXECUTED 10b3b1: 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; 10b3b3: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10b3b6: 83 c3 08 add $0x8,%ebx <== NOT EXECUTED 10b3b9: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b3bb: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b3bd: f7 f1 div %ecx <== NOT EXECUTED 10b3bf: 85 d2 test %edx,%edx <== NOT EXECUTED 10b3c1: 74 05 je 10b3c8 <_Heap_Initialize+0x30> <== NOT EXECUTED 10b3c3: 8d 1c 19 lea (%ecx,%ebx,1),%ebx <== NOT EXECUTED 10b3c6: 29 d3 sub %edx,%ebx <== NOT EXECUTED _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; 10b3c8: 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 */ 10b3cb: 85 f6 test %esi,%esi <== NOT EXECUTED 10b3cd: 0f 85 cd 00 00 00 jne 10b4a0 <_Heap_Initialize+0x108> <== NOT EXECUTED 10b3d3: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 10b3d8: 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); 10b3db: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b3dd: 2b 45 0c sub 0xc(%ebp),%eax <== NOT EXECUTED 10b3e0: 83 c0 08 add $0x8,%eax <== NOT EXECUTED if ( size < overhead ) 10b3e3: 3b 45 10 cmp 0x10(%ebp),%eax <== NOT EXECUTED 10b3e6: 0f 87 a8 00 00 00 ja 10b494 <_Heap_Initialize+0xfc> <== NOT EXECUTED return 0; /* Too small area for the heap */ the_size = size - overhead; 10b3ec: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10b3ef: 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 10b3f1: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b3f3: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b3f5: f7 f1 div %ecx <== NOT EXECUTED _Heap_Align_down ( &the_size, page_size ); if ( the_size == 0 ) 10b3f7: 29 d6 sub %edx,%esi <== NOT EXECUTED 10b3f9: 0f 84 95 00 00 00 je 10b494 <_Heap_Initialize+0xfc> <== NOT EXECUTED return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 10b3ff: 89 4f 10 mov %ecx,0x10(%edi) <== NOT EXECUTED the_heap->begin = starting_address; 10b402: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b405: 89 47 18 mov %eax,0x18(%edi) <== NOT EXECUTED the_heap->end = starting_address + size; 10b408: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b40b: 03 45 10 add 0x10(%ebp),%eax <== NOT EXECUTED 10b40e: 89 47 1c mov %eax,0x1c(%edi) <== NOT EXECUTED the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; 10b411: 89 0b mov %ecx,(%ebx) <== NOT EXECUTED the_block->size = the_size | HEAP_PREV_USED; 10b413: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b415: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10b418: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED the_block->next = _Heap_Tail( the_heap ); 10b41b: 89 7b 08 mov %edi,0x8(%ebx) <== NOT EXECUTED the_block->prev = _Heap_Head( the_heap ); 10b41e: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED _Heap_Head(the_heap)->next = the_block; 10b421: 89 5f 08 mov %ebx,0x8(%edi) <== NOT EXECUTED _Heap_Tail(the_heap)->prev = the_block; 10b424: 89 5f 0c mov %ebx,0xc(%edi) <== NOT EXECUTED the_heap->start = the_block; 10b427: 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 10b42a: 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 */ 10b42d: 89 47 24 mov %eax,0x24(%edi) <== NOT EXECUTED the_block->prev_size = the_size; /* Previous block is free */ 10b430: 89 30 mov %esi,(%eax) <== NOT EXECUTED the_block->size = page_size; 10b432: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED stats->size = size; 10b435: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b438: 89 47 2c mov %eax,0x2c(%edi) <== NOT EXECUTED stats->free_size = the_size; 10b43b: 89 77 30 mov %esi,0x30(%edi) <== NOT EXECUTED stats->min_free_size = the_size; 10b43e: 89 77 34 mov %esi,0x34(%edi) <== NOT EXECUTED stats->free_blocks = 1; 10b441: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi) <== NOT EXECUTED stats->max_free_blocks = 1; 10b448: c7 47 3c 01 00 00 00 movl $0x1,0x3c(%edi) <== NOT EXECUTED stats->used_blocks = 0; 10b44f: c7 47 40 00 00 00 00 movl $0x0,0x40(%edi) <== NOT EXECUTED stats->max_search = 0; 10b456: c7 47 44 00 00 00 00 movl $0x0,0x44(%edi) <== NOT EXECUTED stats->allocs = 0; 10b45d: c7 47 48 00 00 00 00 movl $0x0,0x48(%edi) <== NOT EXECUTED stats->searches = 0; 10b464: c7 47 4c 00 00 00 00 movl $0x0,0x4c(%edi) <== NOT EXECUTED stats->frees = 0; 10b46b: c7 47 50 00 00 00 00 movl $0x0,0x50(%edi) <== NOT EXECUTED stats->resizes = 0; 10b472: c7 47 54 00 00 00 00 movl $0x0,0x54(%edi) <== NOT EXECUTED stats->instance = instance++; 10b479: a1 20 f5 11 00 mov 0x11f520,%eax <== NOT EXECUTED 10b47e: 89 47 28 mov %eax,0x28(%edi) <== NOT EXECUTED 10b481: 40 inc %eax <== NOT EXECUTED 10b482: a3 20 f5 11 00 mov %eax,0x11f520 <== NOT EXECUTED return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 10b487: 8d 46 fc lea -0x4(%esi),%eax <== NOT EXECUTED } 10b48a: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10b48d: 5b pop %ebx <== NOT EXECUTED 10b48e: 5e pop %esi <== NOT EXECUTED 10b48f: 5f pop %edi <== NOT EXECUTED 10b490: c9 leave <== NOT EXECUTED 10b491: c3 ret <== NOT EXECUTED 10b492: 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 ); 10b494: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10b496: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10b499: 5b pop %ebx <== NOT EXECUTED 10b49a: 5e pop %esi <== NOT EXECUTED 10b49b: 5f pop %edi <== NOT EXECUTED 10b49c: c9 leave <== NOT EXECUTED 10b49d: c3 ret <== NOT EXECUTED 10b49e: 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 */ 10b4a0: 8d 41 10 lea 0x10(%ecx),%eax <== NOT EXECUTED 10b4a3: 29 f0 sub %esi,%eax <== NOT EXECUTED 10b4a5: e9 2e ff ff ff jmp 10b3d8 <_Heap_Initialize+0x40> <== NOT EXECUTED 10b4aa: 66 90 xchg %ax,%ax <== NOT EXECUTED 10b4ac: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b4ae: 83 e0 03 and $0x3,%eax <== NOT EXECUTED 10b4b1: 74 05 je 10b4b8 <_Heap_Initialize+0x120> <== NOT EXECUTED 10b4b3: 83 c1 04 add $0x4,%ecx <== NOT EXECUTED 10b4b6: 29 c1 sub %eax,%ecx <== NOT EXECUTED 10b4b8: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 10b4bd: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b4bf: f7 f1 div %ecx <== NOT EXECUTED 10b4c1: 89 d6 mov %edx,%esi <== NOT EXECUTED 10b4c3: e9 eb fe ff ff jmp 10b3b3 <_Heap_Initialize+0x1b> <== NOT EXECUTED 00117528 <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 117528: 55 push %ebp <== NOT EXECUTED 117529: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11752b: 57 push %edi <== NOT EXECUTED 11752c: 56 push %esi <== NOT EXECUTED 11752d: 53 push %ebx <== NOT EXECUTED 11752e: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 117531: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 117534: 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; 117537: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED 11753a: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED uint32_t const page_size = the_heap->page_size; 11753d: 8b 56 10 mov 0x10(%esi),%edx <== NOT EXECUTED 117540: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED *old_mem_size = 0; 117543: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 117546: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED *avail_mem_size = 0; 11754c: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 11754f: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 117555: 8d 59 f8 lea -0x8(%ecx),%ebx <== NOT EXECUTED 117558: 89 c8 mov %ecx,%eax <== NOT EXECUTED 11755a: 31 d2 xor %edx,%edx <== NOT EXECUTED 11755c: f7 76 10 divl 0x10(%esi) <== NOT EXECUTED 11755f: 29 d3 sub %edx,%ebx <== NOT EXECUTED 117561: 8b 56 24 mov 0x24(%esi),%edx <== NOT EXECUTED 117564: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED /* end of include file */ 117567: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 117569: 72 04 jb 11756f <_Heap_Resize_block+0x47> <== NOT EXECUTED 11756b: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 11756d: 76 0d jbe 11757c <_Heap_Resize_block+0x54> <== NOT EXECUTED } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 11756f: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED } 117574: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 117577: 5b pop %ebx <== NOT EXECUTED 117578: 5e pop %esi <== NOT EXECUTED 117579: 5f pop %edi <== NOT EXECUTED 11757a: c9 leave <== NOT EXECUTED 11757b: 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; 11757c: 8b 7b 04 mov 0x4(%ebx),%edi <== NOT EXECUTED 11757f: 89 7d cc mov %edi,-0x34(%ebp) <== NOT EXECUTED 117582: 83 e7 fe and $0xfffffffe,%edi <== NOT EXECUTED 117585: 89 7d d8 mov %edi,-0x28(%ebp) <== NOT EXECUTED 117588: 01 df add %ebx,%edi <== NOT EXECUTED 11758a: 89 7d c0 mov %edi,-0x40(%ebp) <== NOT EXECUTED /* end of include file */ 11758d: 39 f8 cmp %edi,%eax <== NOT EXECUTED 11758f: 77 de ja 11756f <_Heap_Resize_block+0x47> <== NOT EXECUTED 117591: 39 fa cmp %edi,%edx <== NOT EXECUTED 117593: 72 da jb 11756f <_Heap_Resize_block+0x47> <== NOT EXECUTED 117595: 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) || 117598: a8 01 test $0x1,%al <== NOT EXECUTED 11759a: 74 d3 je 11756f <_Heap_Resize_block+0x47> <== NOT EXECUTED 11759c: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 11759f: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 1175a2: 01 f8 add %edi,%eax <== NOT EXECUTED 1175a4: 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) || 1175a7: 39 fa cmp %edi,%edx <== NOT EXECUTED 1175a9: 0f 84 11 01 00 00 je 1176c0 <_Heap_Resize_block+0x198> <== NOT EXECUTED 1175af: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 1175b2: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 1175b5: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 1175b8: 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; 1175bb: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED 1175be: 83 e7 01 and $0x1,%edi <== NOT EXECUTED 1175c1: 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) 1175c4: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 1175c7: 29 c8 sub %ecx,%eax <== NOT EXECUTED 1175c9: 83 c0 04 add $0x4,%eax <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 1175cc: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 1175cf: 89 02 mov %eax,(%edx) <== NOT EXECUTED if (size > old_user_size) { 1175d1: 3b 45 10 cmp 0x10(%ebp),%eax <== NOT EXECUTED 1175d4: 73 3a jae 117610 <_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 */ 1175d6: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 1175da: 75 29 jne 117605 <_Heap_Resize_block+0xdd> <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; else { uint32_t add_block_size = size - old_user_size; 1175dc: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 1175df: 29 c1 sub %eax,%ecx <== NOT EXECUTED 1175e1: 89 c8 mov %ecx,%eax <== NOT EXECUTED 1175e3: 31 d2 xor %edx,%edx <== NOT EXECUTED 1175e5: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED 1175e8: 85 d2 test %edx,%edx <== NOT EXECUTED 1175ea: 74 05 je 1175f1 <_Heap_Resize_block+0xc9> <== NOT EXECUTED 1175ec: 03 4d e4 add -0x1c(%ebp),%ecx <== NOT EXECUTED 1175ef: 29 d1 sub %edx,%ecx <== NOT EXECUTED 1175f1: 89 c8 mov %ecx,%eax <== NOT EXECUTED 1175f3: 3b 4d e0 cmp -0x20(%ebp),%ecx <== NOT EXECUTED 1175f6: 0f 82 a0 00 00 00 jb 11769c <_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) 1175fc: 39 45 d0 cmp %eax,-0x30(%ebp) <== NOT EXECUTED 1175ff: 0f 83 9f 00 00 00 jae 1176a4 <_Heap_Resize_block+0x17c> <== NOT EXECUTED } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 117605: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 11760a: e9 65 ff ff ff jmp 117574 <_Heap_Resize_block+0x4c> <== NOT EXECUTED 11760f: 90 nop <== NOT EXECUTED --stats->used_blocks; } } else { /* Calculate how much memory we could free */ uint32_t free_block_size = old_user_size - size; 117610: 89 c1 mov %eax,%ecx <== NOT EXECUTED 117612: 2b 4d 10 sub 0x10(%ebp),%ecx <== NOT EXECUTED 117615: 89 c8 mov %ecx,%eax <== NOT EXECUTED 117617: 31 d2 xor %edx,%edx <== NOT EXECUTED 117619: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 11761c: 29 d1 sub %edx,%ecx <== NOT EXECUTED 11761e: 89 4d e8 mov %ecx,-0x18(%ebp) <== NOT EXECUTED 117621: 74 69 je 11768c <_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; 117623: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 117626: 29 ca sub %ecx,%edx <== NOT EXECUTED 117628: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED if (new_block_size < min_block_size) { 11762b: 39 55 e0 cmp %edx,-0x20(%ebp) <== NOT EXECUTED 11762e: 76 0d jbe 11763d <_Heap_Resize_block+0x115> <== NOT EXECUTED uint32_t delta = min_block_size - new_block_size; 117630: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 117633: 29 d0 sub %edx,%eax <== NOT EXECUTED _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 117635: 29 45 e8 sub %eax,-0x18(%ebp) <== NOT EXECUTED 117638: 74 52 je 11768c <_Heap_Resize_block+0x164> <== NOT EXECUTED ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; } new_block_size += delta; 11763a: 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) { 11763d: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 117641: 0f 85 85 00 00 00 jne 1176cc <_Heap_Resize_block+0x1a4> <== NOT EXECUTED 117647: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 11764a: 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; 11764d: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 117650: 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; 117653: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 117656: 09 c7 or %eax,%edi <== NOT EXECUTED 117658: 89 7b 04 mov %edi,0x4(%ebx) <== NOT EXECUTED new_next_block->size = new_next_block_size | HEAP_PREV_USED; 11765b: 89 c8 mov %ecx,%eax <== NOT EXECUTED 11765d: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 117660: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED next_next_block->prev_size = new_next_block_size; 117663: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED 117666: 89 0f mov %ecx,(%edi) <== NOT EXECUTED { return (state == SYSTEM_STATE_FAILED); } /**@}*/ 117668: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 11766b: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED #endif 11766e: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED /* end of include file */ 117671: 89 5a 08 mov %ebx,0x8(%edx) <== NOT EXECUTED 117674: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED 117677: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED 11767a: 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; 11767d: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 117680: 01 46 30 add %eax,0x30(%esi) <== NOT EXECUTED *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 117683: 83 e9 04 sub $0x4,%ecx <== NOT EXECUTED 117686: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 117689: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 11768b: 90 nop <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; } } } ++stats->resizes; 11768c: ff 46 54 incl 0x54(%esi) <== NOT EXECUTED 11768f: 31 c0 xor %eax,%eax <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; } 117691: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 117694: 5b pop %ebx <== NOT EXECUTED 117695: 5e pop %esi <== NOT EXECUTED 117696: 5f pop %edi <== NOT EXECUTED 117697: c9 leave <== NOT EXECUTED 117698: c3 ret <== NOT EXECUTED 117699: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 11769c: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 11769f: e9 58 ff ff ff jmp 1175fc <_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 = 1176a4: 52 push %edx <== NOT EXECUTED 1176a5: 50 push %eax <== NOT EXECUTED 1176a6: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED 1176a9: 56 push %esi <== NOT EXECUTED 1176aa: e8 4d 3e ff ff call 10b4fc <_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; 1176af: 03 45 d8 add -0x28(%ebp),%eax <== NOT EXECUTED 1176b2: 0b 45 dc or -0x24(%ebp),%eax <== NOT EXECUTED 1176b5: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED --stats->used_blocks; 1176b8: ff 4e 40 decl 0x40(%esi) <== NOT EXECUTED 1176bb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1176be: eb cc jmp 11768c <_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) || 1176c0: c6 45 f3 01 movb $0x1,-0xd(%ebp) <== NOT EXECUTED 1176c4: e9 f2 fe ff ff jmp 1175bb <_Heap_Resize_block+0x93> <== NOT EXECUTED 1176c9: 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) { 1176cc: 8b 7d e8 mov -0x18(%ebp),%edi <== NOT EXECUTED 1176cf: 39 7d e0 cmp %edi,-0x20(%ebp) <== NOT EXECUTED 1176d2: 77 b8 ja 11768c <_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; 1176d4: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1176d7: 09 45 dc or %eax,-0x24(%ebp) <== NOT EXECUTED 1176da: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 1176dd: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED 1176e0: 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; 1176e3: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 1176e6: 83 ca 01 or $0x1,%edx <== NOT EXECUTED 1176e9: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 1176ec: ff 46 40 incl 0x40(%esi) <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 1176ef: ff 4e 50 decl 0x50(%esi) <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 1176f2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1176f5: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 1176f8: 50 push %eax <== NOT EXECUTED 1176f9: 56 push %esi <== NOT EXECUTED 1176fa: e8 d1 82 ff ff call 10f9d0 <_Heap_Free> <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 1176ff: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 117702: 83 e8 04 sub $0x4,%eax <== NOT EXECUTED 117705: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 117708: 89 02 mov %eax,(%edx) <== NOT EXECUTED 11770a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11770d: e9 7a ff ff ff jmp 11768c <_Heap_Resize_block+0x164> <== NOT EXECUTED 00117714 <_Heap_Size_of_user_area>: bool _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 117714: 55 push %ebp <== NOT EXECUTED 117715: 89 e5 mov %esp,%ebp <== NOT EXECUTED 117717: 57 push %edi <== NOT EXECUTED 117718: 56 push %esi <== NOT EXECUTED 117719: 53 push %ebx <== NOT EXECUTED 11771a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11771d: 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( 117720: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 117723: 8b 70 24 mov 0x24(%eax),%esi <== NOT EXECUTED 117726: 8b 48 20 mov 0x20(%eax),%ecx <== NOT EXECUTED /* end of include file */ 117729: 39 f9 cmp %edi,%ecx <== NOT EXECUTED 11772b: 77 04 ja 117731 <_Heap_Size_of_user_area+0x1d> <== NOT EXECUTED 11772d: 39 fe cmp %edi,%esi <== NOT EXECUTED 11772f: 73 0b jae 11773c <_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 ); 117731: 31 c0 xor %eax,%eax <== NOT EXECUTED } 117733: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 117736: 5b pop %ebx <== NOT EXECUTED 117737: 5e pop %esi <== NOT EXECUTED 117738: 5f pop %edi <== NOT EXECUTED 117739: c9 leave <== NOT EXECUTED 11773a: c3 ret <== NOT EXECUTED 11773b: 90 nop <== NOT EXECUTED 11773c: 8d 57 f8 lea -0x8(%edi),%edx <== NOT EXECUTED 11773f: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 117742: 89 f8 mov %edi,%eax <== NOT EXECUTED 117744: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 117747: 31 d2 xor %edx,%edx <== NOT EXECUTED 117749: f7 73 10 divl 0x10(%ebx) <== NOT EXECUTED 11774c: 29 55 e8 sub %edx,-0x18(%ebp) <== NOT EXECUTED /* end of include file */ 11774f: 3b 4d e8 cmp -0x18(%ebp),%ecx <== NOT EXECUTED 117752: 77 dd ja 117731 <_Heap_Size_of_user_area+0x1d> <== NOT EXECUTED 117754: 3b 75 e8 cmp -0x18(%ebp),%esi <== NOT EXECUTED 117757: 72 d8 jb 117731 <_Heap_Size_of_user_area+0x1d> <== NOT EXECUTED 117759: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 11775c: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 11775f: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 117762: 01 d0 add %edx,%eax <== NOT EXECUTED /* end of include file */ 117764: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 117766: 77 c9 ja 117731 <_Heap_Size_of_user_area+0x1d> <== NOT EXECUTED 117768: 39 c6 cmp %eax,%esi <== NOT EXECUTED 11776a: 72 c5 jb 117731 <_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 ( 11776c: f6 40 04 01 testb $0x1,0x4(%eax) <== NOT EXECUTED 117770: 74 bf je 117731 <_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 ) 117772: 29 f8 sub %edi,%eax <== NOT EXECUTED 117774: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 117777: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 11777a: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 11777c: b0 01 mov $0x1,%al <== NOT EXECUTED 11777e: eb b3 jmp 117733 <_Heap_Size_of_user_area+0x1f> <== NOT EXECUTED 00111cb8 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 111cb8: 55 push %ebp <== NOT EXECUTED 111cb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111cbb: 57 push %edi <== NOT EXECUTED 111cbc: 56 push %esi <== NOT EXECUTED 111cbd: 53 push %ebx <== NOT EXECUTED 111cbe: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 111cc1: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Heap_Block *the_block = the_heap->start; 111cc4: 8b 7e 20 mov 0x20(%esi),%edi <== NOT EXECUTED Heap_Block *const end = the_heap->final; 111cc7: 8b 46 24 mov 0x24(%esi),%eax <== NOT EXECUTED 111cca: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED /* if ( !_System_state_Is_up( _System_state_Get() ) ) return TRUE; */ if (source < 0) 111ccd: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 111cd0: 85 c0 test %eax,%eax <== NOT EXECUTED 111cd2: 0f 88 67 02 00 00 js 111f3f <_Heap_Walk+0x287> <== NOT EXECUTED /* * Handle the 1st block */ if (!_Heap_Is_prev_used(the_block)) { 111cd8: f6 47 04 01 testb $0x1,0x4(%edi) <== NOT EXECUTED 111cdc: 0f 84 3e 02 00 00 je 111f20 <_Heap_Walk+0x268> <== NOT EXECUTED 111ce2: 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) { 111ce9: 8b 07 mov (%edi),%eax <== NOT EXECUTED 111ceb: 3b 46 10 cmp 0x10(%esi),%eax <== NOT EXECUTED 111cee: 74 1a je 111d0a <_Heap_Walk+0x52> <== NOT EXECUTED printk("PASS: %d !prev_size of 1st block isn't page_size\n", source); 111cf0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111cf3: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111cf6: 68 b0 dc 11 00 push $0x11dcb0 <== NOT EXECUTED 111cfb: e8 80 76 ff ff call 109380 <== NOT EXECUTED 111d00: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111d07: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } while ( the_block != end ) { 111d0a: 3b 7d e4 cmp -0x1c(%ebp),%edi <== NOT EXECUTED 111d0d: 0f 84 37 02 00 00 je 111f4a <_Heap_Walk+0x292> <== NOT EXECUTED 111d13: 8b 57 04 mov 0x4(%edi),%edx <== NOT EXECUTED 111d16: 89 d3 mov %edx,%ebx <== NOT EXECUTED 111d18: 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 111d1b: 8d 04 1f lea (%edi,%ebx,1),%eax <== NOT EXECUTED 111d1e: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 111d21: 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 ); 111d24: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 111d27: 39 4e 20 cmp %ecx,0x20(%esi) <== NOT EXECUTED 111d2a: 0f 87 14 01 00 00 ja 111e44 <_Heap_Walk+0x18c> <== NOT EXECUTED 111d30: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 111d32: 0f 87 0c 01 00 00 ja 111e44 <_Heap_Walk+0x18c> <== NOT EXECUTED 111d38: 83 e2 01 and $0x1,%edx <== NOT EXECUTED 111d3b: 88 55 f3 mov %dl,-0xd(%ebp) <== NOT EXECUTED 111d3e: 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)) { 111d40: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 111d43: f6 41 04 01 testb $0x1,0x4(%ecx) <== NOT EXECUTED 111d47: 0f 85 53 01 00 00 jne 111ea0 <_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) { 111d4d: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 111d50: 39 18 cmp %ebx,(%eax) <== NOT EXECUTED 111d52: 74 1a je 111d6e <_Heap_Walk+0xb6> <== NOT EXECUTED if (do_dump) printk("\n"); printk("PASS: %d !front and back sizes don't match", source); 111d54: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111d57: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111d5a: 68 08 dd 11 00 push $0x11dd08 <== NOT EXECUTED 111d5f: e8 1c 76 ff ff call 109380 <== NOT EXECUTED 111d64: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111d6b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } if (!prev_used) { 111d6e: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 111d72: 75 25 jne 111d99 <_Heap_Walk+0xe1> <== NOT EXECUTED if (do_dump || error) printk("\n"); 111d74: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 111d77: 85 c0 test %eax,%eax <== NOT EXECUTED 111d79: 0f 85 81 01 00 00 jne 111f00 <_Heap_Walk+0x248> <== NOT EXECUTED printk("PASS: %d !two consecutive blocks are free", source); 111d7f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111d82: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111d85: 68 34 dd 11 00 push $0x11dd34 <== NOT EXECUTED 111d8a: e8 f1 75 ff ff call 109380 <== NOT EXECUTED 111d8f: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111d96: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { return ( the_thread == _Thread_Heir ); } /** 111d99: 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) 111d9c: 39 c7 cmp %eax,%edi <== NOT EXECUTED 111d9e: 75 13 jne 111db3 <_Heap_Walk+0xfb> <== NOT EXECUTED 111da0: e9 fb 00 00 00 jmp 111ea0 <_Heap_Walk+0x1e8> <== NOT EXECUTED 111da5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED block = block->next; 111da8: 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) 111dab: 39 f8 cmp %edi,%eax <== NOT EXECUTED 111dad: 0f 84 ed 00 00 00 je 111ea0 <_Heap_Walk+0x1e8> <== NOT EXECUTED 111db3: 39 c6 cmp %eax,%esi <== NOT EXECUTED 111db5: 75 f1 jne 111da8 <_Heap_Walk+0xf0> <== NOT EXECUTED block = block->next; if(block != the_block) { if (do_dump || error) printk("\n"); 111db7: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 111dba: 85 c9 test %ecx,%ecx <== NOT EXECUTED 111dbc: 74 10 je 111dce <_Heap_Walk+0x116> <== NOT EXECUTED 111dbe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111dc1: 68 87 b6 11 00 push $0x11b687 <== NOT EXECUTED 111dc6: e8 b5 75 ff ff call 109380 <== NOT EXECUTED 111dcb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED printk("PASS: %d !the_block not in the free list", source); 111dce: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111dd1: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111dd4: 68 60 dd 11 00 push $0x11dd60 <== NOT EXECUTED 111dd9: e8 a2 75 ff ff call 109380 <== NOT EXECUTED 111dde: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111de5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } } } if (do_dump || error) printk("\n"); 111de8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111deb: 68 87 b6 11 00 push $0x11b687 <== NOT EXECUTED 111df0: e8 8b 75 ff ff call 109380 <== NOT EXECUTED 111df5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (the_size < the_heap->min_block_size) { 111df8: 3b 5e 14 cmp 0x14(%esi),%ebx <== NOT EXECUTED 111dfb: 0f 82 b3 00 00 00 jb 111eb4 <_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)) { 111e01: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111e03: 31 d2 xor %edx,%edx <== NOT EXECUTED 111e05: f7 76 10 divl 0x10(%esi) <== NOT EXECUTED 111e08: 85 d2 test %edx,%edx <== NOT EXECUTED 111e0a: 0f 85 d8 00 00 00 jne 111ee8 <_Heap_Walk+0x230> <== NOT EXECUTED printk("PASS: %d !block size is misaligned\n", source); error = 1; } if (++passes > (do_dump ? 10 : 0) && error) 111e10: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 111e13: 85 c0 test %eax,%eax <== NOT EXECUTED 111e15: 75 41 jne 111e58 <_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 ) { 111e17: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 111e1a: 39 4d e4 cmp %ecx,-0x1c(%ebp) <== NOT EXECUTED 111e1d: 0f 84 27 01 00 00 je 111f4a <_Heap_Walk+0x292> <== NOT EXECUTED 111e23: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 111e26: 8b 48 04 mov 0x4(%eax),%ecx <== NOT EXECUTED 111e29: 89 cb mov %ecx,%ebx <== NOT EXECUTED 111e2b: 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 ); 111e2e: 01 d8 add %ebx,%eax <== NOT EXECUTED 111e30: 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 ); 111e33: 3b 46 20 cmp 0x20(%esi),%eax <== NOT EXECUTED 111e36: 0f 83 90 00 00 00 jae 111ecc <_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)) { 111e3c: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 111e3f: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 111e42: 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); 111e44: 50 push %eax <== NOT EXECUTED 111e45: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 111e48: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111e4b: 68 e4 dc 11 00 push $0x11dce4 <== NOT EXECUTED 111e50: e8 2b 75 ff ff call 109380 <== NOT EXECUTED 111e55: 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", 111e58: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 111e5b: 57 push %edi <== NOT EXECUTED 111e5c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111e5f: 68 d4 dd 11 00 push $0x11ddd4 <== NOT EXECUTED 111e64: e8 17 75 ff ff call 109380 <== NOT EXECUTED 111e69: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111e70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111e73: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 111e76: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED source, the_block, end); error = 1; } if (_Heap_Block_size(the_block) != the_heap->page_size) { 111e79: 8b 56 10 mov 0x10(%esi),%edx <== NOT EXECUTED 111e7c: 39 c2 cmp %eax,%edx <== NOT EXECUTED 111e7e: 0f 84 91 00 00 00 je 111f15 <_Heap_Walk+0x25d> <== NOT EXECUTED printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source, 111e84: 52 push %edx <== NOT EXECUTED 111e85: 50 push %eax <== NOT EXECUTED 111e86: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111e89: 68 10 de 11 00 push $0x11de10 <== NOT EXECUTED 111e8e: e8 ed 74 ff ff call 109380 <== NOT EXECUTED 111e93: b0 01 mov $0x1,%al <== NOT EXECUTED 111e95: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if(do_dump && error) _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 ); return error; } 111e98: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111e9b: 5b pop %ebx <== NOT EXECUTED 111e9c: 5e pop %esi <== NOT EXECUTED 111e9d: 5f pop %edi <== NOT EXECUTED 111e9e: c9 leave <== NOT EXECUTED 111e9f: c3 ret <== NOT EXECUTED error = 1; } } } if (do_dump || error) printk("\n"); 111ea0: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 111ea3: 85 d2 test %edx,%edx <== NOT EXECUTED 111ea5: 0f 85 3d ff ff ff jne 111de8 <_Heap_Walk+0x130> <== NOT EXECUTED if (the_size < the_heap->min_block_size) { 111eab: 3b 5e 14 cmp 0x14(%esi),%ebx <== NOT EXECUTED 111eae: 0f 83 4d ff ff ff jae 111e01 <_Heap_Walk+0x149> <== NOT EXECUTED printk("PASS: %d !block size is too small\n", source); 111eb4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111eb7: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111eba: 68 8c dd 11 00 push $0x11dd8c <== NOT EXECUTED 111ebf: e8 bc 74 ff ff call 109380 <== NOT EXECUTED 111ec4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111ec7: eb 8f jmp 111e58 <_Heap_Walk+0x1a0> <== NOT EXECUTED 111ec9: 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 ); 111ecc: 39 d0 cmp %edx,%eax <== NOT EXECUTED 111ece: 0f 87 68 ff ff ff ja 111e3c <_Heap_Walk+0x184> <== NOT EXECUTED 111ed4: 83 e1 01 and $0x1,%ecx <== NOT EXECUTED 111ed7: 88 4d f3 mov %cl,-0xd(%ebp) <== NOT EXECUTED 111eda: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 111edd: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 111ee0: e9 5b fe ff ff jmp 111d40 <_Heap_Walk+0x88> <== NOT EXECUTED 111ee5: 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); 111ee8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111eeb: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111eee: 68 b0 dd 11 00 push $0x11ddb0 <== NOT EXECUTED 111ef3: e8 88 74 ff ff call 109380 <== NOT EXECUTED 111ef8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111efb: e9 58 ff ff ff jmp 111e58 <_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"); 111f00: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111f03: 68 87 b6 11 00 push $0x11b687 <== NOT EXECUTED 111f08: e8 73 74 ff ff call 109380 <== NOT EXECUTED 111f0d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111f10: e9 6a fe ff ff jmp 111d7f <_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) { 111f15: 8a 45 e8 mov -0x18(%ebp),%al <== NOT EXECUTED if(do_dump && error) _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 ); return error; } 111f18: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111f1b: 5b pop %ebx <== NOT EXECUTED 111f1c: 5e pop %esi <== NOT EXECUTED 111f1d: 5f pop %edi <== NOT EXECUTED 111f1e: c9 leave <== NOT EXECUTED 111f1f: 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); 111f20: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111f23: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111f26: 68 78 dc 11 00 push $0x11dc78 <== NOT EXECUTED 111f2b: e8 50 74 ff ff call 109380 <== NOT EXECUTED 111f30: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111f37: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111f3a: e9 aa fd ff ff jmp 111ce9 <_Heap_Walk+0x31> <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) return TRUE; */ if (source < 0) source = the_heap->stats.instance; 111f3f: 8b 4e 28 mov 0x28(%esi),%ecx <== NOT EXECUTED 111f42: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED 111f45: e9 8e fd ff ff jmp 111cd8 <_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, 111f4a: 8b 7d e4 mov -0x1c(%ebp),%edi <== NOT EXECUTED 111f4d: e9 21 ff ff ff jmp 111e73 <_Heap_Walk+0x1bb> <== NOT EXECUTED 0010aa5c <_IO_Initialize_all_drivers>: * * Output Parameters: NONE */ void _IO_Initialize_all_drivers( void ) { 10aa5c: 55 push %ebp <== NOT EXECUTED 10aa5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa5f: 53 push %ebx <== NOT EXECUTED 10aa60: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10aa63: 8b 15 20 02 12 00 mov 0x120220,%edx <== NOT EXECUTED 10aa69: 85 d2 test %edx,%edx <== NOT EXECUTED 10aa6b: 74 1a je 10aa87 <_IO_Initialize_all_drivers+0x2b> <== NOT EXECUTED 10aa6d: 31 db xor %ebx,%ebx <== NOT EXECUTED 10aa6f: 90 nop <== NOT EXECUTED (void) rtems_io_initialize( major, 0, NULL ); 10aa70: 50 push %eax <== NOT EXECUTED 10aa71: 6a 00 push $0x0 <== NOT EXECUTED 10aa73: 6a 00 push $0x0 <== NOT EXECUTED 10aa75: 53 push %ebx <== NOT EXECUTED 10aa76: e8 fd 4b 00 00 call 10f678 <== NOT EXECUTED void _IO_Initialize_all_drivers( void ) { rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10aa7b: 43 inc %ebx <== NOT EXECUTED 10aa7c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aa7f: 39 1d 20 02 12 00 cmp %ebx,0x120220 <== NOT EXECUTED 10aa85: 77 e9 ja 10aa70 <_IO_Initialize_all_drivers+0x14> <== NOT EXECUTED (void) rtems_io_initialize( major, 0, NULL ); } 10aa87: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10aa8a: c9 leave <== NOT EXECUTED 10aa8b: c3 ret <== NOT EXECUTED 0010aa8c <_IO_Manager_initialization>: void _IO_Manager_initialization( rtems_driver_address_table *driver_table, uint32_t drivers_in_table, uint32_t number_of_drivers ) { 10aa8c: 55 push %ebp <== NOT EXECUTED 10aa8d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa8f: 57 push %edi <== NOT EXECUTED 10aa90: 56 push %esi <== NOT EXECUTED 10aa91: 53 push %ebx <== NOT EXECUTED 10aa92: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa95: 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 ) 10aa98: 3b 75 0c cmp 0xc(%ebp),%esi <== NOT EXECUTED 10aa9b: 76 5b jbe 10aaf8 <_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 *) 10aa9d: 8d 04 76 lea (%esi,%esi,2),%eax <== NOT EXECUTED 10aaa0: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx <== NOT EXECUTED 10aaa7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aaaa: 53 push %ebx <== NOT EXECUTED 10aaab: e8 e8 29 00 00 call 10d498 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10aab0: 89 c7 mov %eax,%edi <== NOT EXECUTED 10aab2: a3 24 02 12 00 mov %eax,0x120224 <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; 10aab7: 89 35 20 02 12 00 mov %esi,0x120220 <== NOT EXECUTED memset( 10aabd: 31 c0 xor %eax,%eax <== NOT EXECUTED 10aabf: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 10aac1: 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++ ) 10aac3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aac6: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10aac9: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10aacb: 74 23 je 10aaf0 <_IO_Manager_initialization+0x64> <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 10aacd: 8b 1d 24 02 12 00 mov 0x120224,%ebx <== NOT EXECUTED 10aad3: 31 d2 xor %edx,%edx <== NOT EXECUTED 10aad5: 31 c0 xor %eax,%eax <== NOT EXECUTED 10aad7: 90 nop <== NOT EXECUTED 10aad8: 8d 3c 03 lea (%ebx,%eax,1),%edi <== NOT EXECUTED 10aadb: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10aade: 01 c6 add %eax,%esi <== NOT EXECUTED 10aae0: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10aae5: 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++ ) 10aae7: 42 inc %edx <== NOT EXECUTED 10aae8: 83 c0 18 add $0x18,%eax <== NOT EXECUTED 10aaeb: 39 55 0c cmp %edx,0xc(%ebp) <== NOT EXECUTED 10aaee: 77 e8 ja 10aad8 <_IO_Manager_initialization+0x4c> <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; number_of_drivers = drivers_in_table; } 10aaf0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aaf3: 5b pop %ebx <== NOT EXECUTED 10aaf4: 5e pop %esi <== NOT EXECUTED 10aaf5: 5f pop %edi <== NOT EXECUTED 10aaf6: c9 leave <== NOT EXECUTED 10aaf7: 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; 10aaf8: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10aafb: a3 24 02 12 00 mov %eax,0x120224 <== NOT EXECUTED _IO_Number_of_drivers = number_of_drivers; 10ab00: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10ab03: 89 0d 20 02 12 00 mov %ecx,0x120220 <== NOT EXECUTED ); for ( index = 0 ; index < drivers_in_table ; index++ ) _IO_Driver_address_table[index] = driver_table[index]; number_of_drivers = drivers_in_table; } 10ab09: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ab0c: 5b pop %ebx <== NOT EXECUTED 10ab0d: 5e pop %esi <== NOT EXECUTED 10ab0e: 5f pop %edi <== NOT EXECUTED 10ab0f: c9 leave <== NOT EXECUTED 10ab10: c3 ret <== NOT EXECUTED 0010b5c0 <_ISR_Handler_initialization>: * * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { 10b5c0: 55 push %ebp <== NOT EXECUTED 10b5c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b5c3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED _ISR_Signals_to_thread_executing = FALSE; 10b5c6: c6 05 28 f9 11 00 00 movb $0x0,0x11f928 <== NOT EXECUTED _ISR_Nest_level = 0; 10b5cd: c7 05 58 f8 11 00 00 movl $0x0,0x11f858 <== NOT EXECUTED 10b5d4: 00 00 00 <== NOT EXECUTED _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( !_Stack_Is_enough(_Configuration_Table->interrupt_stack_size) ) 10b5d7: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10b5dc: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10b5df: 3b 05 d0 b1 11 00 cmp 0x11b1d0,%eax <== NOT EXECUTED 10b5e5: 72 21 jb 10b608 <_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( 10b5e7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b5ea: 50 push %eax <== NOT EXECUTED 10b5eb: e8 a8 1e 00 00 call 10d498 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10b5f0: a3 c8 f7 11 00 mov %eax,0x11f7c8 <== NOT EXECUTED _Configuration_Table->interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 10b5f5: 8b 15 54 f8 11 00 mov 0x11f854,%edx <== NOT EXECUTED 10b5fb: 03 42 1c add 0x1c(%edx),%eax <== NOT EXECUTED 10b5fe: a3 88 f7 11 00 mov %eax,0x11f788 <== NOT EXECUTED 10b603: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE ) _CPU_Install_interrupt_stack(); #endif } 10b606: c9 leave <== NOT EXECUTED 10b607: 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( 10b608: 50 push %eax <== NOT EXECUTED 10b609: 6a 05 push $0x5 <== NOT EXECUTED 10b60b: 6a 01 push $0x1 <== NOT EXECUTED 10b60d: 6a 00 push $0x0 <== NOT EXECUTED 10b60f: e8 6c ff ff ff call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED 0010b580 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) { 10b580: 55 push %ebp <== NOT EXECUTED 10b581: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b583: 53 push %ebx <== NOT EXECUTED 10b584: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b587: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b58a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b58d: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED _Internal_errors_What_happened.the_source = the_source; 10b590: 89 15 64 f8 11 00 mov %edx,0x11f864 <== NOT EXECUTED _Internal_errors_What_happened.is_internal = is_internal; 10b596: a2 68 f8 11 00 mov %al,0x11f868 <== NOT EXECUTED _Internal_errors_What_happened.the_error = the_error; 10b59b: 89 1d 6c f8 11 00 mov %ebx,0x11f86c <== NOT EXECUTED _User_extensions_Fatal( the_source, is_internal, the_error ); 10b5a1: 53 push %ebx <== NOT EXECUTED 10b5a2: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10b5a5: 50 push %eax <== NOT EXECUTED 10b5a6: 52 push %edx <== NOT EXECUTED 10b5a7: e8 60 1b 00 00 call 10d10c <_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( 10b5ac: c7 05 84 f9 11 00 05 movl $0x5,0x11f984 <== NOT EXECUTED 10b5b3: 00 00 00 <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10b5b6: fa cli <== NOT EXECUTED 10b5b7: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b5b9: f4 hlt <== NOT EXECUTED 10b5ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b5bd: eb fe jmp 10b5bd <_Internal_error_Occurred+0x3d> <== NOT EXECUTED 0010f2e8 <_Interrupt_Manager_initialization>: * * Output parameters: NONE */ void _Interrupt_Manager_initialization( void ) { 10f2e8: 55 push %ebp <== NOT EXECUTED 10f2e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED } 10f2eb: c9 leave <== NOT EXECUTED 10f2ec: c3 ret <== NOT EXECUTED 001260b0 <_Message_queue_Allocate>: * Output parameters: * the_message_queue - set if successful, NULL otherwise */ Message_queue_Control *_Message_queue_Allocate(void) { 1260b0: 55 push %ebp <== NOT EXECUTED 1260b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1260b3: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED return (Message_queue_Control *) 1260b6: 68 40 2a 16 00 push $0x162a40 <== NOT EXECUTED 1260bb: e8 d0 a7 fe ff call 110890 <_Objects_Allocate> <== NOT EXECUTED _Objects_Allocate(&_Message_queue_Information); } 1260c0: c9 leave <== NOT EXECUTED 1260c1: c3 ret <== NOT EXECUTED 0010f2f0 <_Message_queue_Manager_initialization>: */ void _Message_queue_Manager_initialization( uint32_t maximum_message_queues ) { 10f2f0: 55 push %ebp <== NOT EXECUTED 10f2f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f2f3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f2f6: 6a 04 push $0x4 <== NOT EXECUTED 10f2f8: 6a 00 push $0x0 <== NOT EXECUTED 10f2fa: 68 88 00 00 00 push $0x88 <== NOT EXECUTED 10f2ff: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f302: 6a 04 push $0x4 <== NOT EXECUTED 10f304: 6a 02 push $0x2 <== NOT EXECUTED 10f306: 68 a0 01 12 00 push $0x1201a0 <== NOT EXECUTED 10f30b: e8 5c c8 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10f310: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_MESSAGE_QUEUE, _Message_queue_MP_Process_packet ); #endif } 10f313: c9 leave <== NOT EXECUTED 10f314: 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 54 d5 11 00 mov 0x11d554(,%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 0010fb30 <_Objects_API_maximum_class>: #include int _Objects_API_maximum_class( uint32_t api ) { 10fb30: 55 push %ebp <== NOT EXECUTED 10fb31: 89 e5 mov %esp,%ebp <== NOT EXECUTED switch (api) { 10fb33: 83 7d 08 02 cmpl $0x2,0x8(%ebp) <== NOT EXECUTED 10fb37: 74 2f je 10fb68 <_Objects_API_maximum_class+0x38> <== NOT EXECUTED 10fb39: 76 15 jbe 10fb50 <_Objects_API_maximum_class+0x20> <== NOT EXECUTED 10fb3b: 83 7d 08 03 cmpl $0x3,0x8(%ebp) <== NOT EXECUTED 10fb3f: 74 1f je 10fb60 <_Objects_API_maximum_class+0x30> <== NOT EXECUTED 10fb41: 83 7d 08 04 cmpl $0x4,0x8(%ebp) <== NOT EXECUTED 10fb45: 75 0f jne 10fb56 <_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; 10fb47: b8 08 00 00 00 mov $0x8,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10fb4c: c9 leave <== NOT EXECUTED 10fb4d: c3 ret <== NOT EXECUTED 10fb4e: 66 90 xchg %ax,%ax <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10fb50: 83 7d 08 01 cmpl $0x1,0x8(%ebp) <== NOT EXECUTED 10fb54: 74 1a je 10fb70 <_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; 10fb56: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10fb5b: c9 leave <== NOT EXECUTED 10fb5c: c3 ret <== NOT EXECUTED 10fb5d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10fb60: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10fb65: c9 leave <== NOT EXECUTED 10fb66: c3 ret <== NOT EXECUTED 10fb67: 90 nop <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10fb68: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10fb6d: c9 leave <== NOT EXECUTED 10fb6e: c3 ret <== NOT EXECUTED 10fb6f: 90 nop <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10fb70: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10fb75: c9 leave <== NOT EXECUTED 10fb76: c3 ret <== NOT EXECUTED 0010b614 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10b614: 55 push %ebp <== NOT EXECUTED 10b615: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b617: 56 push %esi <== NOT EXECUTED 10b618: 53 push %ebx <== NOT EXECUTED 10b619: 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 ) 10b61c: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10b61f: 85 c0 test %eax,%eax <== NOT EXECUTED 10b621: 75 0d jne 10b630 <_Objects_Allocate+0x1c> <== NOT EXECUTED 10b623: 31 c9 xor %ecx,%ecx <== NOT EXECUTED information->inactive--; } } return the_object; } 10b625: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b627: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b62a: 5b pop %ebx <== NOT EXECUTED 10b62b: 5e pop %esi <== NOT EXECUTED 10b62c: c9 leave <== NOT EXECUTED 10b62d: c3 ret <== NOT EXECUTED 10b62e: 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 ); 10b630: 8d 73 20 lea 0x20(%ebx),%esi <== NOT EXECUTED 10b633: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b636: 56 push %esi <== NOT EXECUTED 10b637: e8 c4 f7 ff ff call 10ae00 <_Chain_Get> <== NOT EXECUTED 10b63c: 89 c1 mov %eax,%ecx <== NOT EXECUTED if ( information->auto_extend ) { 10b63e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b641: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10b645: 74 de je 10b625 <_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 ) { 10b647: 85 c0 test %eax,%eax <== NOT EXECUTED 10b649: 74 2d je 10b678 <_Objects_Allocate+0x64> <== NOT EXECUTED } if ( the_object ) { uint32_t block; block = _Objects_Get_index( the_object->id ) - 10b64b: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10b64e: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10b653: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10b656: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10b65c: 29 d0 sub %edx,%eax <== NOT EXECUTED _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]--; 10b65e: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b660: f7 73 14 divl 0x14(%ebx) <== NOT EXECUTED 10b663: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b666: 03 43 30 add 0x30(%ebx),%eax <== NOT EXECUTED 10b669: ff 08 decl (%eax) <== NOT EXECUTED information->inactive--; 10b66b: 66 ff 4b 2c decw 0x2c(%ebx) <== NOT EXECUTED } } return the_object; } 10b66f: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b671: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b674: 5b pop %ebx <== NOT EXECUTED 10b675: 5e pop %esi <== NOT EXECUTED 10b676: c9 leave <== NOT EXECUTED 10b677: 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 ); 10b678: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b67b: 53 push %ebx <== NOT EXECUTED 10b67c: e8 37 00 00 00 call 10b6b8 <_Objects_Extend_information> <== NOT EXECUTED the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10b681: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10b684: e8 77 f7 ff ff call 10ae00 <_Chain_Get> <== NOT EXECUTED 10b689: 89 c1 mov %eax,%ecx <== NOT EXECUTED } if ( the_object ) { 10b68b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b68e: 85 c0 test %eax,%eax <== NOT EXECUTED 10b690: 74 93 je 10b625 <_Objects_Allocate+0x11> <== NOT EXECUTED 10b692: eb b7 jmp 10b64b <_Objects_Allocate+0x37> <== NOT EXECUTED 0010b694 <_Objects_Close>: void _Objects_Close( Objects_Information *information, Objects_Control *the_object ) { 10b694: 55 push %ebp <== NOT EXECUTED 10b695: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b697: 53 push %ebx <== NOT EXECUTED 10b698: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b69b: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10b69e: 0f b7 51 08 movzwl 0x8(%ecx),%edx <== NOT EXECUTED 10b6a2: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10b6a5: 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 ); 10b6ac: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED } 10b6af: 5b pop %ebx <== NOT EXECUTED 10b6b0: c9 leave <== NOT EXECUTED Objects_Control *the_object ) { _Objects_Invalidate_Id( information, the_object ); _Objects_Namespace_remove( information, the_object ); 10b6b1: e9 76 05 00 00 jmp 10bc2c <_Objects_Namespace_remove> <== NOT EXECUTED 0010b6b8 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 10b6b8: 55 push %ebp <== NOT EXECUTED 10b6b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b6bb: 57 push %edi <== NOT EXECUTED 10b6bc: 56 push %esi <== NOT EXECUTED 10b6bd: 53 push %ebx <== NOT EXECUTED 10b6be: 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 10b6c1: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b6c4: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10b6c7: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10b6cc: 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 ) 10b6cf: 0f b7 72 10 movzwl 0x10(%edx),%esi <== NOT EXECUTED 10b6d3: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10b6d5: 0f 83 e9 01 00 00 jae 10b8c4 <_Objects_Extend_information+0x20c> <== NOT EXECUTED 10b6db: 8b 4a 14 mov 0x14(%edx),%ecx <== NOT EXECUTED 10b6de: 89 4d a8 mov %ecx,-0x58(%ebp) <== NOT EXECUTED 10b6e1: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED 10b6e4: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp) <== NOT EXECUTED 10b6eb: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b6ed: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) <== NOT EXECUTED 10b6f4: ba 03 00 00 00 mov $0x3,%edx <== NOT EXECUTED * Up the block count and maximum */ block_count++; maximum = information->maximum + information->allocation_size; 10b6f9: 03 75 a8 add -0x58(%ebp),%esi <== NOT EXECUTED 10b6fc: 89 75 d4 mov %esi,-0x2c(%ebp) <== NOT EXECUTED /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 10b6ff: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b702: 80 78 12 00 cmpb $0x0,0x12(%eax) <== NOT EXECUTED 10b706: 0f 85 1c 02 00 00 jne 10b928 <_Objects_Extend_information+0x270> <== NOT EXECUTED if ( !object_blocks ) return; } else { object_blocks = (void**) 10b70c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b70f: 8b 75 c8 mov -0x38(%ebp),%esi <== NOT EXECUTED 10b712: 8d 04 32 lea (%edx,%esi,1),%eax <== NOT EXECUTED 10b715: 03 45 d4 add -0x2c(%ebp),%eax <== NOT EXECUTED 10b718: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b71b: 50 push %eax <== NOT EXECUTED 10b71c: e8 77 1d 00 00 call 10d498 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10b721: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED 10b724: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 10b727: 8b 7d e0 mov -0x20(%ebp),%edi <== NOT EXECUTED 10b72a: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10b72d: 8d 3c b8 lea (%eax,%edi,4),%edi <== NOT EXECUTED 10b730: 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 10b733: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 10b736: 8d 14 d0 lea (%eax,%edx,8),%edx <== NOT EXECUTED 10b739: 89 55 d8 mov %edx,-0x28(%ebp) <== NOT EXECUTED * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 10b73c: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b73f: 0f b7 41 10 movzwl 0x10(%ecx),%eax <== NOT EXECUTED 10b743: 3b 45 c8 cmp -0x38(%ebp),%eax <== NOT EXECUTED 10b746: 0f 87 38 02 00 00 ja 10b984 <_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++ ) { 10b74c: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 10b74f: 85 c0 test %eax,%eax <== NOT EXECUTED 10b751: 74 15 je 10b768 <_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, 10b753: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b755: 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; 10b758: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 10b75b: 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++ ) { 10b762: 40 inc %eax <== NOT EXECUTED 10b763: 3b 45 c8 cmp -0x38(%ebp),%eax <== NOT EXECUTED 10b766: 72 f0 jb 10b758 <_Objects_Extend_information+0xa0> <== NOT EXECUTED /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 10b768: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 10b76b: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b76e: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED 10b771: c7 04 01 00 00 00 00 movl $0x0,(%ecx,%eax,1) <== NOT EXECUTED inactive_per_block[block_count] = 0; 10b778: 8b 75 d0 mov -0x30(%ebp),%esi <== NOT EXECUTED 10b77b: c7 04 06 00 00 00 00 movl $0x0,(%esi,%eax,1) <== NOT EXECUTED for ( index=index_base ; index < ( information->allocation_size + index_base ); 10b782: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED 10b785: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b788: 03 4f 14 add 0x14(%edi),%ecx <== NOT EXECUTED 10b78b: 39 4d c4 cmp %ecx,-0x3c(%ebp) <== NOT EXECUTED 10b78e: 73 1a jae 10b7aa <_Objects_Extend_information+0xf2> <== NOT EXECUTED 10b790: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED 10b793: 8b 75 d8 mov -0x28(%ebp),%esi <== NOT EXECUTED 10b796: 8d 14 86 lea (%esi,%eax,4),%edx <== NOT EXECUTED 10b799: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED index++ ) { local_table[ index ] = NULL; 10b79c: 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++ ) { 10b7a2: 40 inc %eax <== NOT EXECUTED 10b7a3: 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 ); 10b7a6: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10b7a8: 72 f2 jb 10b79c <_Objects_Extend_information+0xe4> <== NOT EXECUTED index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 10b7aa: 9c pushf <== NOT EXECUTED 10b7ab: fa cli <== NOT EXECUTED 10b7ac: 59 pop %ecx <== NOT EXECUTED old_tables = information->object_blocks; 10b7ad: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b7b0: 8b 77 34 mov 0x34(%edi),%esi <== NOT EXECUTED information->object_blocks = object_blocks; 10b7b3: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10b7b6: 89 47 34 mov %eax,0x34(%edi) <== NOT EXECUTED information->inactive_per_block = inactive_per_block; 10b7b9: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 10b7bc: 89 57 30 mov %edx,0x30(%edi) <== NOT EXECUTED information->local_table = local_table; 10b7bf: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 10b7c2: 89 47 1c mov %eax,0x1c(%edi) <== NOT EXECUTED information->maximum = maximum; 10b7c5: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 10b7c8: 66 89 57 10 mov %dx,0x10(%edi) <== NOT EXECUTED information->maximum_id = _Objects_Build_id( 10b7cc: 8b 17 mov (%edi),%edx <== NOT EXECUTED 10b7ce: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10b7d1: 81 ca 00 00 01 00 or $0x10000,%edx <== NOT EXECUTED 10b7d7: 0f b7 47 04 movzwl 0x4(%edi),%eax <== NOT EXECUTED 10b7db: c1 e0 1b shl $0x1b,%eax <== NOT EXECUTED 10b7de: 09 c2 or %eax,%edx <== NOT EXECUTED 10b7e0: 0f b7 45 d4 movzwl -0x2c(%ebp),%eax <== NOT EXECUTED 10b7e4: 09 c2 or %eax,%edx <== NOT EXECUTED 10b7e6: 89 57 0c mov %edx,0xc(%edi) <== NOT EXECUTED information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 10b7e9: 51 push %ecx <== NOT EXECUTED 10b7ea: 9d popf <== NOT EXECUTED if ( old_tables ) 10b7eb: 85 f6 test %esi,%esi <== NOT EXECUTED 10b7ed: 0f 84 c9 01 00 00 je 10b9bc <_Objects_Extend_information+0x304> <== NOT EXECUTED _Workspace_Free( old_tables ); 10b7f3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b7f6: 56 push %esi <== NOT EXECUTED 10b7f7: e8 6c 1c 00 00 call 10d468 <_Workspace_Free> <== NOT EXECUTED 10b7fc: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10b7ff: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED 10b802: 89 75 a8 mov %esi,-0x58(%ebp) <== NOT EXECUTED 10b805: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 10b808: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b80b: 80 7f 12 00 cmpb $0x0,0x12(%edi) <== NOT EXECUTED 10b80f: 0f 84 3b 01 00 00 je 10b950 <_Objects_Extend_information+0x298> <== NOT EXECUTED information->object_blocks[ block ] = 10b815: c1 e3 02 shl $0x2,%ebx <== NOT EXECUTED 10b818: 89 5d dc mov %ebx,-0x24(%ebp) <== NOT EXECUTED 10b81b: 03 5f 34 add 0x34(%edi),%ebx <== NOT EXECUTED 10b81e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b821: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED 10b824: 0f af 47 18 imul 0x18(%edi),%eax <== NOT EXECUTED 10b828: 50 push %eax <== NOT EXECUTED 10b829: e8 52 1c 00 00 call 10d480 <_Workspace_Allocate> <== NOT EXECUTED 10b82e: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Workspace_Allocate( (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 10b830: 8b 47 34 mov 0x34(%edi),%eax <== NOT EXECUTED 10b833: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 10b836: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10b839: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b83c: 85 c0 test %eax,%eax <== NOT EXECUTED 10b83e: 74 7a je 10b8ba <_Objects_Extend_information+0x202> <== NOT EXECUTED /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 10b840: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b843: ff 71 18 pushl 0x18(%ecx) <== NOT EXECUTED 10b846: ff 71 14 pushl 0x14(%ecx) <== NOT EXECUTED 10b849: 50 push %eax <== NOT EXECUTED 10b84a: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 10b84d: 56 push %esi <== NOT EXECUTED 10b84e: e8 7d 3e 00 00 call 10f6d0 <_Chain_Initialize> <== NOT EXECUTED information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10b853: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10b856: 83 c6 20 add $0x20,%esi <== NOT EXECUTED 10b859: 8b 5d c4 mov -0x3c(%ebp),%ebx <== NOT EXECUTED 10b85c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b85f: eb 2c jmp 10b88d <_Objects_Extend_information+0x1d5> <== NOT EXECUTED 10b861: 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( 10b864: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b867: 8b 07 mov (%edi),%eax <== NOT EXECUTED 10b869: c1 e0 18 shl $0x18,%eax <== NOT EXECUTED 10b86c: 0d 00 00 01 00 or $0x10000,%eax <== NOT EXECUTED 10b871: 0f b7 57 04 movzwl 0x4(%edi),%edx <== NOT EXECUTED 10b875: c1 e2 1b shl $0x1b,%edx <== NOT EXECUTED 10b878: 09 d0 or %edx,%eax <== NOT EXECUTED 10b87a: 09 d8 or %ebx,%eax <== NOT EXECUTED 10b87c: 89 41 08 mov %eax,0x8(%ecx) <== NOT EXECUTED information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10b87f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b882: 51 push %ecx <== NOT EXECUTED 10b883: 56 push %esi <== NOT EXECUTED 10b884: e8 53 f5 ff ff call 10addc <_Chain_Append> <== NOT EXECUTED index++; 10b889: 43 inc %ebx <== NOT EXECUTED 10b88a: 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 ) { 10b88d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b890: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10b893: 50 push %eax <== NOT EXECUTED 10b894: e8 67 f5 ff ff call 10ae00 <_Chain_Get> <== NOT EXECUTED 10b899: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b89b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b89e: 85 c0 test %eax,%eax <== NOT EXECUTED 10b8a0: 75 c2 jne 10b864 <_Objects_Extend_information+0x1ac> <== NOT EXECUTED _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 10b8a2: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b8a5: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10b8a8: 89 d1 mov %edx,%ecx <== NOT EXECUTED 10b8aa: 8b 52 14 mov 0x14(%edx),%edx <== NOT EXECUTED 10b8ad: 8b 75 dc mov -0x24(%ebp),%esi <== NOT EXECUTED 10b8b0: 89 14 30 mov %edx,(%eax,%esi,1) <== NOT EXECUTED information->inactive += information->allocation_size; 10b8b3: 8b 41 14 mov 0x14(%ecx),%eax <== NOT EXECUTED 10b8b6: 66 01 41 2c add %ax,0x2c(%ecx) <== NOT EXECUTED } 10b8ba: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b8bd: 5b pop %ebx <== NOT EXECUTED 10b8be: 5e pop %esi <== NOT EXECUTED 10b8bf: 5f pop %edi <== NOT EXECUTED 10b8c0: c9 leave <== NOT EXECUTED 10b8c1: c3 ret <== NOT EXECUTED 10b8c2: 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; 10b8c4: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b8c7: 8b 7f 14 mov 0x14(%edi),%edi <== NOT EXECUTED 10b8ca: 89 7d a8 mov %edi,-0x58(%ebp) <== NOT EXECUTED 10b8cd: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b8cf: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b8d1: f7 f7 div %edi <== NOT EXECUTED 10b8d3: 89 45 a4 mov %eax,-0x5c(%ebp) <== NOT EXECUTED 10b8d6: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED for ( ; block < block_count; block++ ) { 10b8d9: 85 c0 test %eax,%eax <== NOT EXECUTED 10b8db: 0f 84 e6 00 00 00 je 10b9c7 <_Objects_Extend_information+0x30f> <== NOT EXECUTED if ( information->object_blocks[ block ] == NULL ) 10b8e1: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b8e4: 8b 4f 34 mov 0x34(%edi),%ecx <== NOT EXECUTED 10b8e7: 8b 19 mov (%ecx),%ebx <== NOT EXECUTED 10b8e9: 85 db test %ebx,%ebx <== NOT EXECUTED 10b8eb: 0f 84 d6 00 00 00 je 10b9c7 <_Objects_Extend_information+0x30f> <== NOT EXECUTED 10b8f1: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 10b8f4: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED 10b8f7: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b8f9: eb 08 jmp 10b903 <_Objects_Extend_information+0x24b> <== NOT EXECUTED 10b8fb: 90 nop <== NOT EXECUTED 10b8fc: 8b 14 99 mov (%ecx,%ebx,4),%edx <== NOT EXECUTED 10b8ff: 85 d2 test %edx,%edx <== NOT EXECUTED 10b901: 74 0c je 10b90f <_Objects_Extend_information+0x257> <== NOT EXECUTED break; else index_base += information->allocation_size; 10b903: 8b 55 a8 mov -0x58(%ebp),%edx <== NOT EXECUTED 10b906: 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++ ) { 10b909: 43 inc %ebx <== NOT EXECUTED 10b90a: 39 5d a4 cmp %ebx,-0x5c(%ebp) <== NOT EXECUTED 10b90d: 77 ed ja 10b8fc <_Objects_Extend_information+0x244> <== NOT EXECUTED /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 10b90f: 39 75 c4 cmp %esi,-0x3c(%ebp) <== NOT EXECUTED 10b912: 0f 82 f0 fe ff ff jb 10b808 <_Objects_Extend_information+0x150> <== NOT EXECUTED 10b918: 8b 7d a4 mov -0x5c(%ebp),%edi <== NOT EXECUTED 10b91b: 47 inc %edi <== NOT EXECUTED 10b91c: 89 7d e0 mov %edi,-0x20(%ebp) <== NOT EXECUTED 10b91f: 8d 14 7f lea (%edi,%edi,2),%edx <== NOT EXECUTED 10b922: e9 d2 fd ff ff jmp 10b6f9 <_Objects_Extend_information+0x41> <== NOT EXECUTED 10b927: 90 nop <== NOT EXECUTED /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { object_blocks = (void**) 10b928: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b92b: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED 10b92e: 8d 04 0a lea (%edx,%ecx,1),%eax <== NOT EXECUTED 10b931: 01 f0 add %esi,%eax <== NOT EXECUTED 10b933: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b936: 50 push %eax <== NOT EXECUTED 10b937: e8 44 1b 00 00 call 10d480 <_Workspace_Allocate> <== NOT EXECUTED 10b93c: 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 ) 10b93f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b942: 85 c0 test %eax,%eax <== NOT EXECUTED 10b944: 0f 85 dd fd ff ff jne 10b727 <_Objects_Extend_information+0x6f> <== NOT EXECUTED 10b94a: e9 6b ff ff ff jmp 10b8ba <_Objects_Extend_information+0x202> <== NOT EXECUTED 10b94f: 90 nop <== NOT EXECUTED if ( !information->object_blocks[ block ] ) return; } else { information->object_blocks[ block ] = 10b950: c1 e3 02 shl $0x2,%ebx <== NOT EXECUTED 10b953: 89 5d dc mov %ebx,-0x24(%ebp) <== NOT EXECUTED 10b956: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b959: 03 59 34 add 0x34(%ecx),%ebx <== NOT EXECUTED 10b95c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b95f: 8b 75 a8 mov -0x58(%ebp),%esi <== NOT EXECUTED 10b962: 0f af 71 18 imul 0x18(%ecx),%esi <== NOT EXECUTED 10b966: 56 push %esi <== NOT EXECUTED 10b967: e8 2c 1b 00 00 call 10d498 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10b96c: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10b96e: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b971: 8b 47 34 mov 0x34(%edi),%eax <== NOT EXECUTED 10b974: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 10b977: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10b97a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b97d: e9 be fe ff ff jmp 10b840 <_Objects_Extend_information+0x188> <== NOT EXECUTED 10b982: 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, 10b984: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 10b987: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b98a: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b98d: 8b 77 34 mov 0x34(%edi),%esi <== NOT EXECUTED 10b990: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED 10b993: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b995: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 10b997: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b99a: 8b 72 30 mov 0x30(%edx),%esi <== NOT EXECUTED 10b99d: 8b 7d d0 mov -0x30(%ebp),%edi <== NOT EXECUTED 10b9a0: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b9a2: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 10b9a4: 0f b7 4a 10 movzwl 0x10(%edx),%ecx <== NOT EXECUTED 10b9a8: 03 4d c8 add -0x38(%ebp),%ecx <== NOT EXECUTED 10b9ab: c1 e1 02 shl $0x2,%ecx <== NOT EXECUTED 10b9ae: 8b 72 1c mov 0x1c(%edx),%esi <== NOT EXECUTED 10b9b1: 8b 7d d8 mov -0x28(%ebp),%edi <== NOT EXECUTED 10b9b4: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10b9b6: e9 ad fd ff ff jmp 10b768 <_Objects_Extend_information+0xb0> <== NOT EXECUTED 10b9bb: 90 nop <== NOT EXECUTED information->maximum ); _ISR_Enable( level ); if ( old_tables ) 10b9bc: 8b 4f 14 mov 0x14(%edi),%ecx <== NOT EXECUTED 10b9bf: 89 4d a8 mov %ecx,-0x58(%ebp) <== NOT EXECUTED 10b9c2: e9 41 fe ff ff jmp 10b808 <_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++ ) { 10b9c7: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED 10b9ca: 89 4d c4 mov %ecx,-0x3c(%ebp) <== NOT EXECUTED 10b9cd: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b9cf: e9 3b ff ff ff jmp 10b90f <_Objects_Extend_information+0x257> <== NOT EXECUTED 0010b9d4 <_Objects_Free>: void _Objects_Free( Objects_Information *information, Objects_Control *the_object ) { 10b9d4: 55 push %ebp <== NOT EXECUTED 10b9d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b9d7: 57 push %edi <== NOT EXECUTED 10b9d8: 56 push %esi <== NOT EXECUTED 10b9d9: 53 push %ebx <== NOT EXECUTED 10b9da: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10b9dd: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b9e0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED uint32_t allocation_size = information->allocation_size; 10b9e3: 8b 7b 14 mov 0x14(%ebx),%edi <== NOT EXECUTED _Chain_Append( &information->Inactive, &the_object->Node ); 10b9e6: 56 push %esi <== NOT EXECUTED 10b9e7: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED 10b9ea: 50 push %eax <== NOT EXECUTED 10b9eb: e8 ec f3 ff ff call 10addc <_Chain_Append> <== NOT EXECUTED if ( information->auto_extend ) { 10b9f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b9f3: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10b9f7: 74 35 je 10ba2e <_Objects_Free+0x5a> <== NOT EXECUTED uint32_t block; block = 10b9f9: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10b9fc: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10ba01: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10ba04: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10ba0a: 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 ]++; 10ba0c: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ba0e: f7 73 14 divl 0x14(%ebx) <== NOT EXECUTED 10ba11: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10ba14: 03 43 30 add 0x30(%ebx),%eax <== NOT EXECUTED 10ba17: ff 00 incl (%eax) <== NOT EXECUTED information->inactive++; 10ba19: 8b 53 2c mov 0x2c(%ebx),%edx <== NOT EXECUTED 10ba1c: 42 inc %edx <== NOT EXECUTED 10ba1d: 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 ) ) ) { 10ba21: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10ba24: 89 f8 mov %edi,%eax <== NOT EXECUTED 10ba26: d1 e8 shr %eax <== NOT EXECUTED 10ba28: 01 f8 add %edi,%eax <== NOT EXECUTED 10ba2a: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10ba2c: 77 0a ja 10ba38 <_Objects_Free+0x64> <== NOT EXECUTED _Objects_Shrink_information( information ); } } } 10ba2e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ba31: 5b pop %ebx <== NOT EXECUTED 10ba32: 5e pop %esi <== NOT EXECUTED 10ba33: 5f pop %edi <== NOT EXECUTED 10ba34: c9 leave <== NOT EXECUTED 10ba35: c3 ret <== NOT EXECUTED 10ba36: 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 ); 10ba38: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } } 10ba3b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ba3e: 5b pop %ebx <== NOT EXECUTED 10ba3f: 5e pop %esi <== NOT EXECUTED 10ba40: 5f pop %edi <== NOT EXECUTED 10ba41: 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 ); 10ba42: e9 a5 02 00 00 jmp 10bcec <_Objects_Shrink_information> <== NOT EXECUTED 0010bb08 <_Objects_Get>: Objects_Control *_Objects_Get( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 10bb08: 55 push %ebp <== NOT EXECUTED 10bb09: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb0b: 53 push %ebx <== NOT EXECUTED 10bb0c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bb0f: 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; 10bb12: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10bb17: 2b 51 08 sub 0x8(%ecx),%edx <== NOT EXECUTED 10bb1a: 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 ) { 10bb1d: 0f b7 41 10 movzwl 0x10(%ecx),%eax <== NOT EXECUTED 10bb21: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10bb23: 77 27 ja 10bb4c <_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 10bb25: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10bb2a: 40 inc %eax <== NOT EXECUTED 10bb2b: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED _Thread_Disable_dispatch(); if ( (the_object = information->local_table[ index ]) != NULL ) { 10bb30: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 10bb33: 8b 1c 90 mov (%eax,%edx,4),%ebx <== NOT EXECUTED 10bb36: 85 db test %ebx,%ebx <== NOT EXECUTED 10bb38: 74 1f je 10bb59 <_Objects_Get+0x51> <== NOT EXECUTED *location = OBJECTS_LOCAL; 10bb3a: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10bb3d: 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 } 10bb43: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bb45: 5a pop %edx <== NOT EXECUTED 10bb46: 5b pop %ebx <== NOT EXECUTED 10bb47: c9 leave <== NOT EXECUTED 10bb48: c3 ret <== NOT EXECUTED 10bb49: 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; 10bb4c: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10bb4f: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10bb55: 31 db xor %ebx,%ebx <== NOT EXECUTED 10bb57: eb ea jmp 10bb43 <_Objects_Get+0x3b> <== NOT EXECUTED /* * Valid Id for this API, Class and Node but the object has not * been allocated yet. */ _Thread_Enable_dispatch(); 10bb59: e8 ee 07 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED *location = OBJECTS_ERROR; 10bb5e: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10bb61: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10bb67: eb da jmp 10bb43 <_Objects_Get+0x3b> <== NOT EXECUTED 0010ba68 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint32_t the_class ) { 10ba68: 55 push %ebp <== NOT EXECUTED 10ba69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ba6b: 53 push %ebx <== NOT EXECUTED 10ba6c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10ba6f: 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. 10ba72: 8d 43 ff lea -0x1(%ebx),%eax <== NOT EXECUTED 10ba75: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10ba78: 77 07 ja 10ba81 <_Objects_Get_information+0x19> <== NOT EXECUTED int the_class_api_maximum; if ( !_Objects_Is_api_valid( the_api ) ) return NULL; if ( !the_class ) 10ba7a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ba7d: 85 c0 test %eax,%eax <== NOT EXECUTED 10ba7f: 75 07 jne 10ba88 <_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 ) 10ba81: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; #endif return info; } 10ba83: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ba86: c9 leave <== NOT EXECUTED 10ba87: c3 ret <== NOT EXECUTED return NULL; if ( !the_class ) return NULL; the_class_api_maximum = _Objects_API_maximum_class( the_api ); 10ba88: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ba8b: 53 push %ebx <== NOT EXECUTED 10ba8c: e8 9f 40 00 00 call 10fb30 <_Objects_API_maximum_class> <== NOT EXECUTED if ( the_class_api_maximum < 0 || 10ba91: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ba94: 85 c0 test %eax,%eax <== NOT EXECUTED 10ba96: 78 e9 js 10ba81 <_Objects_Get_information+0x19> <== NOT EXECUTED 10ba98: 39 45 0c cmp %eax,0xc(%ebp) <== NOT EXECUTED 10ba9b: 77 e4 ja 10ba81 <_Objects_Get_information+0x19> <== NOT EXECUTED the_class > (uint32_t) the_class_api_maximum ) return NULL; if ( !_Objects_Information_table[ the_api ] ) 10ba9d: 8b 04 9d 8c f7 11 00 mov 0x11f78c(,%ebx,4),%eax <== NOT EXECUTED 10baa4: 85 c0 test %eax,%eax <== NOT EXECUTED 10baa6: 74 d9 je 10ba81 <_Objects_Get_information+0x19> <== NOT EXECUTED return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10baa8: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10baab: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED if ( !info ) 10baae: 85 c0 test %eax,%eax <== NOT EXECUTED 10bab0: 74 d1 je 10ba83 <_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 ) 10bab2: 66 83 78 10 00 cmpw $0x0,0x10(%eax) <== NOT EXECUTED 10bab7: 75 ca jne 10ba83 <_Objects_Get_information+0x1b> <== NOT EXECUTED 10bab9: eb c6 jmp 10ba81 <_Objects_Get_information+0x19> <== NOT EXECUTED 0010ba48 <_Objects_Get_information_id>: #include Objects_Information *_Objects_Get_information_id( Objects_Id id ) { 10ba48: 55 push %ebp <== NOT EXECUTED 10ba49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ba4b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ba4e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED return _Objects_Get_information( 10ba51: 89 c2 mov %eax,%edx <== NOT EXECUTED 10ba53: c1 ea 1b shr $0x1b,%edx <== NOT EXECUTED 10ba56: 52 push %edx <== NOT EXECUTED 10ba57: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10ba5a: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 10ba5d: 50 push %eax <== NOT EXECUTED 10ba5e: e8 05 00 00 00 call 10ba68 <_Objects_Get_information> <== NOT EXECUTED _Objects_Get_API( id ), _Objects_Get_class( id ) ); } 10ba63: c9 leave <== NOT EXECUTED 10ba64: c3 ret <== NOT EXECUTED 0010babc <_Objects_Get_isr_disable>: Objects_Information *information, Objects_Id id, Objects_Locations *location, ISR_Level *level_p ) { 10babc: 55 push %ebp <== NOT EXECUTED 10babd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10babf: 56 push %esi <== NOT EXECUTED 10bac0: 53 push %ebx <== NOT EXECUTED 10bac1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bac4: 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; 10bac7: 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 ); 10bacb: 9c pushf <== NOT EXECUTED 10bacc: fa cli <== NOT EXECUTED 10bacd: 59 pop %ecx <== NOT EXECUTED if ( information->maximum >= index ) { 10bace: 0f b7 43 10 movzwl 0x10(%ebx),%eax <== NOT EXECUTED 10bad2: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10bad4: 77 1a ja 10baf0 <_Objects_Get_isr_disable+0x34> <== NOT EXECUTED if ( (the_object = information->local_table[ index ]) != NULL ) { 10bad6: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10bad9: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED 10badc: 85 c0 test %eax,%eax <== NOT EXECUTED 10bade: 74 1c je 10bafc <_Objects_Get_isr_disable+0x40> <== NOT EXECUTED *location = OBJECTS_LOCAL; 10bae0: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED *level_p = level; 10bae6: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10bae9: 89 0a mov %ecx,(%edx) <== NOT EXECUTED _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 10baeb: 5b pop %ebx <== NOT EXECUTED 10baec: 5e pop %esi <== NOT EXECUTED 10baed: c9 leave <== NOT EXECUTED 10baee: c3 ret <== NOT EXECUTED 10baef: 90 nop <== NOT EXECUTED } _ISR_Enable( level ); *location = OBJECTS_ERROR; return NULL; } _ISR_Enable( level ); 10baf0: 51 push %ecx <== NOT EXECUTED 10baf1: 9d popf <== NOT EXECUTED *location = OBJECTS_ERROR; 10baf2: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 10baf8: 31 c0 xor %eax,%eax <== NOT EXECUTED 10bafa: eb ef jmp 10baeb <_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 ); 10bafc: 51 push %ecx <== NOT EXECUTED 10bafd: 9d popf <== NOT EXECUTED *location = OBJECTS_ERROR; 10bafe: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 10bb04: eb e5 jmp 10baeb <_Objects_Get_isr_disable+0x2f> <== NOT EXECUTED 00116ad4 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 116ad4: 55 push %ebp <== NOT EXECUTED 116ad5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116ad7: 57 push %edi <== NOT EXECUTED 116ad8: 56 push %esi <== NOT EXECUTED 116ad9: 53 push %ebx <== NOT EXECUTED 116ada: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 116add: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 116ae0: 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 ) 116ae3: 85 f6 test %esi,%esi <== NOT EXECUTED 116ae5: 75 0d jne 116af4 <_Objects_Get_name_as_string+0x20> <== NOT EXECUTED } } *d = '\0'; _Thread_Enable_dispatch(); return name; 116ae7: 31 db xor %ebx,%ebx <== NOT EXECUTED } return NULL; /* unreachable path */ } 116ae9: 89 d8 mov %ebx,%eax <== NOT EXECUTED 116aeb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116aee: 5b pop %ebx <== NOT EXECUTED 116aef: 5e pop %esi <== NOT EXECUTED 116af0: 5f pop %edi <== NOT EXECUTED 116af1: c9 leave <== NOT EXECUTED 116af2: c3 ret <== NOT EXECUTED 116af3: 90 nop <== NOT EXECUTED Objects_Id tmpId; if ( length == 0 ) return NULL; if ( name == NULL ) 116af4: 85 db test %ebx,%ebx <== NOT EXECUTED 116af6: 74 f1 je 116ae9 <_Objects_Get_name_as_string+0x15> <== NOT EXECUTED return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 116af8: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 116afb: 85 ff test %edi,%edi <== NOT EXECUTED 116afd: 0f 84 8d 00 00 00 je 116b90 <_Objects_Get_name_as_string+0xbc> <== NOT EXECUTED 116b03: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 116b06: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 116b09: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 116b0c: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 116b0f: e8 40 9d ff ff call 110854 <_Objects_Get_information_id> <== NOT EXECUTED 116b14: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( !information ) 116b16: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116b19: 85 c0 test %eax,%eax <== NOT EXECUTED 116b1b: 74 ca je 116ae7 <_Objects_Get_name_as_string+0x13> <== NOT EXECUTED return NULL; the_object = _Objects_Get( information, tmpId, &location ); 116b1d: 51 push %ecx <== NOT EXECUTED 116b1e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 116b21: 50 push %eax <== NOT EXECUTED 116b22: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 116b25: 57 push %edi <== NOT EXECUTED 116b26: e8 e9 9d ff ff call 110914 <_Objects_Get> <== NOT EXECUTED switch ( location ) { 116b2b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116b2e: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 116b31: 85 d2 test %edx,%edx <== NOT EXECUTED 116b33: 75 b2 jne 116ae7 <_Objects_Get_name_as_string+0x13> <== NOT EXECUTED case OBJECTS_ERROR: return NULL; case OBJECTS_LOCAL: if ( information->is_string ) { 116b35: 80 7f 38 00 cmpb $0x0,0x38(%edi) <== NOT EXECUTED 116b39: 74 65 je 116ba0 <_Objects_Get_name_as_string+0xcc> <== NOT EXECUTED s = the_object->name.name_p; 116b3b: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 116b3e: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED lname[ 4 ] = '\0'; s = lname; } d = name; if ( s ) { 116b41: 85 c0 test %eax,%eax <== NOT EXECUTED 116b43: 0f 84 84 00 00 00 je 116bcd <_Objects_Get_name_as_string+0xf9> <== NOT EXECUTED for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 116b49: 4e dec %esi <== NOT EXECUTED 116b4a: 89 75 d8 mov %esi,-0x28(%ebp) <== NOT EXECUTED 116b4d: 74 7e je 116bcd <_Objects_Get_name_as_string+0xf9> <== NOT EXECUTED 116b4f: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 116b52: 8a 08 mov (%eax),%cl <== NOT EXECUTED 116b54: 84 c9 test %cl,%cl <== NOT EXECUTED 116b56: 74 75 je 116bcd <_Objects_Get_name_as_string+0xf9> <== NOT EXECUTED 116b58: 89 df mov %ebx,%edi <== NOT EXECUTED 116b5a: 31 f6 xor %esi,%esi <== NOT EXECUTED 116b5c: eb 0c jmp 116b6a <_Objects_Get_name_as_string+0x96> <== NOT EXECUTED 116b5e: 66 90 xchg %ax,%ax <== NOT EXECUTED 116b60: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 116b63: 8a 0c 30 mov (%eax,%esi,1),%cl <== NOT EXECUTED 116b66: 84 c9 test %cl,%cl <== NOT EXECUTED 116b68: 74 19 je 116b83 <_Objects_Get_name_as_string+0xaf> <== NOT EXECUTED *d = (isprint(*s)) ? *s : '*'; 116b6a: 0f be d1 movsbl %cl,%edx <== NOT EXECUTED 116b6d: a1 28 b4 12 00 mov 0x12b428,%eax <== NOT EXECUTED 116b72: f6 04 10 97 testb $0x97,(%eax,%edx,1) <== NOT EXECUTED 116b76: 75 02 jne 116b7a <_Objects_Get_name_as_string+0xa6> <== NOT EXECUTED 116b78: b1 2a mov $0x2a,%cl <== NOT EXECUTED 116b7a: 88 0f mov %cl,(%edi) <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 116b7c: 46 inc %esi <== NOT EXECUTED 116b7d: 47 inc %edi <== NOT EXECUTED 116b7e: 3b 75 d8 cmp -0x28(%ebp),%esi <== NOT EXECUTED 116b81: 72 dd jb 116b60 <_Objects_Get_name_as_string+0x8c> <== NOT EXECUTED *d = (isprint(*s)) ? *s : '*'; } } *d = '\0'; 116b83: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 116b86: e8 cd a5 ff ff call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED 116b8b: e9 59 ff ff ff jmp 116ae9 <_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; 116b90: a1 7c dd 12 00 mov 0x12dd7c,%eax <== NOT EXECUTED 116b95: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 116b98: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 116b9b: e9 69 ff ff ff jmp 116b09 <_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; 116ba0: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED lname[ 0 ] = (u32_name >> 24) & 0xff; 116ba3: 89 d0 mov %edx,%eax <== NOT EXECUTED 116ba5: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 116ba8: 88 45 eb mov %al,-0x15(%ebp) <== NOT EXECUTED lname[ 1 ] = (u32_name >> 16) & 0xff; 116bab: 89 d0 mov %edx,%eax <== NOT EXECUTED 116bad: c1 e8 10 shr $0x10,%eax <== NOT EXECUTED 116bb0: 88 45 ec mov %al,-0x14(%ebp) <== NOT EXECUTED lname[ 2 ] = (u32_name >> 8) & 0xff; 116bb3: 89 d0 mov %edx,%eax <== NOT EXECUTED 116bb5: c1 e8 08 shr $0x8,%eax <== NOT EXECUTED 116bb8: 88 45 ed mov %al,-0x13(%ebp) <== NOT EXECUTED lname[ 3 ] = (u32_name >> 0) & 0xff; 116bbb: 88 55 ee mov %dl,-0x12(%ebp) <== NOT EXECUTED lname[ 4 ] = '\0'; 116bbe: c6 45 ef 00 movb $0x0,-0x11(%ebp) <== NOT EXECUTED 116bc2: 8d 45 eb lea -0x15(%ebp),%eax <== NOT EXECUTED 116bc5: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED 116bc8: e9 7c ff ff ff jmp 116b49 <_Objects_Get_name_as_string+0x75> <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 116bcd: 89 df mov %ebx,%edi <== NOT EXECUTED 116bcf: eb b2 jmp 116b83 <_Objects_Get_name_as_string+0xaf> <== NOT EXECUTED 0011942c <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 11942c: 55 push %ebp <== NOT EXECUTED 11942d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11942f: 57 push %edi <== NOT EXECUTED 119430: 56 push %esi <== NOT EXECUTED 119431: 53 push %ebx <== NOT EXECUTED 119432: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 119435: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 119438: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11943b: 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) 11943e: 66 85 c0 test %ax,%ax <== NOT EXECUTED 119441: 74 2d je 119470 <_Objects_Get_next+0x44> <== NOT EXECUTED 119443: 89 c3 mov %eax,%ebx <== NOT EXECUTED 119445: 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) 119448: 66 39 5f 10 cmp %bx,0x10(%edi) <== NOT EXECUTED 11944c: 72 2e jb 11947c <_Objects_Get_next+0x50> <== NOT EXECUTED *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 11944e: 51 push %ecx <== NOT EXECUTED 11944f: 56 push %esi <== NOT EXECUTED 119450: 53 push %ebx <== NOT EXECUTED 119451: 57 push %edi <== NOT EXECUTED 119452: e8 bd 74 ff ff call 110914 <_Objects_Get> <== NOT EXECUTED next_id++; 119457: 43 inc %ebx <== NOT EXECUTED } while (*location_p != OBJECTS_LOCAL); 119458: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11945b: 8b 16 mov (%esi),%edx <== NOT EXECUTED 11945d: 85 d2 test %edx,%edx <== NOT EXECUTED 11945f: 75 e7 jne 119448 <_Objects_Get_next+0x1c> <== NOT EXECUTED *next_id_p = next_id; 119461: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 119464: 89 1a mov %ebx,(%edx) <== NOT EXECUTED return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 119466: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 119469: 5b pop %ebx <== NOT EXECUTED 11946a: 5e pop %esi <== NOT EXECUTED 11946b: 5f pop %edi <== NOT EXECUTED 11946c: c9 leave <== NOT EXECUTED 11946d: c3 ret <== NOT EXECUTED 11946e: 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; 119470: 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) 119473: 66 39 5f 10 cmp %bx,0x10(%edi) <== NOT EXECUTED 119477: 73 d5 jae 11944e <_Objects_Get_next+0x22> <== NOT EXECUTED 119479: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { *location_p = OBJECTS_ERROR; 11947c: 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; 119482: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 119485: c7 00 ff ff ff ff movl $0xffffffff,(%eax) <== NOT EXECUTED 11948b: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 11948d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 119490: 5b pop %ebx <== NOT EXECUTED 119491: 5e pop %esi <== NOT EXECUTED 119492: 5f pop %edi <== NOT EXECUTED 119493: c9 leave <== NOT EXECUTED 119494: c3 ret <== NOT EXECUTED 00116c00 <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 116c00: 55 push %ebp <== NOT EXECUTED 116c01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116c03: 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; 116c06: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 116c0b: 2b 51 08 sub 0x8(%ecx),%edx <== NOT EXECUTED 116c0e: 03 55 0c add 0xc(%ebp),%edx <== NOT EXECUTED if ( information->maximum >= index ) { 116c11: 0f b7 41 10 movzwl 0x10(%ecx),%eax <== NOT EXECUTED 116c15: 39 c2 cmp %eax,%edx <== NOT EXECUTED 116c17: 77 17 ja 116c30 <_Objects_Get_no_protection+0x30> <== NOT EXECUTED if ( (the_object = information->local_table[ index ]) != NULL ) { 116c19: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 116c1c: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED 116c1f: 85 c0 test %eax,%eax <== NOT EXECUTED 116c21: 74 0d je 116c30 <_Objects_Get_no_protection+0x30> <== NOT EXECUTED *location = OBJECTS_LOCAL; 116c23: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 116c26: 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; } 116c2c: c9 leave <== NOT EXECUTED 116c2d: c3 ret <== NOT EXECUTED 116c2e: 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; 116c30: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 116c33: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 116c39: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; } 116c3b: c9 leave <== NOT EXECUTED 116c3c: c3 ret <== NOT EXECUTED 0010bce4 <_Objects_Handler_initialization>: uint32_t maximum_nodes, uint32_t maximum_global_objects ) #else void _Objects_Handler_initialization(void) #endif { 10bce4: 55 push %ebp <== NOT EXECUTED 10bce5: 89 e5 mov %esp,%ebp <== NOT EXECUTED node, maximum_nodes, maximum_global_objects ); #endif } 10bce7: c9 leave <== NOT EXECUTED 10bce8: c3 ret <== NOT EXECUTED 0010cb9c <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10cb9c: 55 push %ebp <== NOT EXECUTED 10cb9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cb9f: 53 push %ebx <== NOT EXECUTED 10cba0: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10cba3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cba6: 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 ) 10cba9: 85 db test %ebx,%ebx <== NOT EXECUTED 10cbab: 74 7b je 10cc28 <_Objects_Id_to_name+0x8c> <== NOT EXECUTED return OBJECTS_INVALID_NAME; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10cbad: 85 c0 test %eax,%eax <== NOT EXECUTED 10cbaf: 74 53 je 10cc04 <_Objects_Id_to_name+0x68> <== NOT EXECUTED 10cbb1: 89 c1 mov %eax,%ecx <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10cbb3: 89 ca mov %ecx,%edx <== NOT EXECUTED 10cbb5: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10cbb8: 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. 10cbbb: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10cbbe: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10cbc1: 77 59 ja 10cc1c <_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 ] ) 10cbc3: 8b 14 95 2c 27 12 00 mov 0x12272c(,%edx,4),%edx <== NOT EXECUTED 10cbca: 85 d2 test %edx,%edx <== NOT EXECUTED 10cbcc: 74 4e je 10cc1c <_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 ]; 10cbce: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10cbd0: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED 10cbd3: 8b 14 82 mov (%edx,%eax,4),%edx <== NOT EXECUTED if ( !information ) 10cbd6: 85 d2 test %edx,%edx <== NOT EXECUTED 10cbd8: 74 42 je 10cc1c <_Objects_Id_to_name+0x80> <== NOT EXECUTED return OBJECTS_INVALID_ID; if ( information->is_string ) 10cbda: 80 7a 38 00 cmpb $0x0,0x38(%edx) <== NOT EXECUTED 10cbde: 75 3c jne 10cc1c <_Objects_Id_to_name+0x80> <== NOT EXECUTED return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &ignored_location ); 10cbe0: 50 push %eax <== NOT EXECUTED 10cbe1: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10cbe4: 50 push %eax <== NOT EXECUTED 10cbe5: 51 push %ecx <== NOT EXECUTED 10cbe6: 52 push %edx <== NOT EXECUTED 10cbe7: e8 4c ff ff ff call 10cb38 <_Objects_Get> <== NOT EXECUTED if ( !the_object ) 10cbec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cbef: 85 c0 test %eax,%eax <== NOT EXECUTED 10cbf1: 74 29 je 10cc1c <_Objects_Id_to_name+0x80> <== NOT EXECUTED return OBJECTS_INVALID_ID; *name = the_object->name; 10cbf3: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10cbf6: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10cbf8: e8 13 08 00 00 call 10d410 <_Thread_Enable_dispatch> <== NOT EXECUTED 10cbfd: 31 c0 xor %eax,%eax <== NOT EXECUTED return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 10cbff: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cc02: c9 leave <== NOT EXECUTED 10cc03: 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; 10cc04: a1 1c 28 12 00 mov 0x12281c,%eax <== NOT EXECUTED 10cc09: 8b 48 08 mov 0x8(%eax),%ecx <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10cc0c: 89 ca mov %ecx,%edx <== NOT EXECUTED 10cc0e: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10cc11: 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. 10cc14: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10cc17: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10cc1a: 76 a7 jbe 10cbc3 <_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; 10cc1c: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } 10cc21: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cc24: c9 leave <== NOT EXECUTED 10cc25: c3 ret <== NOT EXECUTED 10cc26: 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 ) 10cc28: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10cc2d: eb f2 jmp 10cc21 <_Objects_Id_to_name+0x85> <== NOT EXECUTED 0010bb6c <_Objects_Initialize_information>: , bool supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 10bb6c: 55 push %ebp <== NOT EXECUTED 10bb6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb6f: 57 push %edi <== NOT EXECUTED 10bb70: 56 push %esi <== NOT EXECUTED 10bb71: 53 push %ebx <== NOT EXECUTED 10bb72: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10bb75: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10bb78: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10bb7b: 8b 75 20 mov 0x20(%ebp),%esi <== NOT EXECUTED 10bb7e: 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; 10bb82: 89 17 mov %edx,(%edi) <== NOT EXECUTED information->the_class = the_class; 10bb84: 66 89 5f 04 mov %bx,0x4(%edi) <== NOT EXECUTED information->is_string = is_string; 10bb88: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 10bb8b: 88 47 38 mov %al,0x38(%edi) <== NOT EXECUTED information->local_table = 0; information->inactive_per_block = 0; 10bb8e: c7 47 30 00 00 00 00 movl $0x0,0x30(%edi) <== NOT EXECUTED information->object_blocks = 0; 10bb95: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi) <== NOT EXECUTED information->inactive = 0; 10bb9c: 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; 10bba2: 8b 04 95 8c f7 11 00 mov 0x11f78c(,%edx,4),%eax <== NOT EXECUTED 10bba9: 89 3c 98 mov %edi,(%eax,%ebx,4) <== NOT EXECUTED /* * Set the size of the object */ information->size = size; 10bbac: 89 4f 18 mov %ecx,0x18(%edi) <== NOT EXECUTED /* * Are we operating in unlimited, or auto-extend mode */ information->auto_extend = 10bbaf: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10bbb2: c1 e8 1f shr $0x1f,%eax <== NOT EXECUTED 10bbb5: 88 47 12 mov %al,0x12(%edi) <== NOT EXECUTED (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE; maximum &= ~OBJECTS_UNLIMITED_OBJECTS; 10bbb8: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10bbbb: 81 e1 ff ff ff 7f and $0x7fffffff,%ecx <== NOT EXECUTED /* * The allocation unit is the maximum value */ information->allocation_size = maximum; 10bbc1: 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; 10bbc4: c7 47 1c 24 f5 11 00 movl $0x11f524,0x1c(%edi) <== NOT EXECUTED */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 10bbcb: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10bbce: 81 ca 00 00 01 00 or $0x10000,%edx <== NOT EXECUTED 10bbd4: c1 e3 1b shl $0x1b,%ebx <== NOT EXECUTED 10bbd7: 09 da or %ebx,%edx <== NOT EXECUTED 10bbd9: 31 c0 xor %eax,%eax <== NOT EXECUTED 10bbdb: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bbdd: 0f 95 c0 setne %al <== NOT EXECUTED 10bbe0: 09 c2 or %eax,%edx <== NOT EXECUTED 10bbe2: 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) ) 10bbe5: f7 c6 03 00 00 00 test $0x3,%esi <== NOT EXECUTED 10bbeb: 75 23 jne 10bc10 <_Objects_Initialize_information+0xa4> <== NOT EXECUTED 10bbed: 89 f0 mov %esi,%eax <== NOT EXECUTED name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & ~(OBJECTS_NAME_ALIGNMENT-1); information->name_length = name_length; 10bbef: 66 89 47 3a mov %ax,0x3a(%edi) <== NOT EXECUTED 10bbf3: 8d 47 24 lea 0x24(%edi),%eax <== NOT EXECUTED 10bbf6: 89 47 20 mov %eax,0x20(%edi) <== NOT EXECUTED 10bbf9: c7 47 24 00 00 00 00 movl $0x0,0x24(%edi) <== NOT EXECUTED 10bc00: 8d 47 20 lea 0x20(%edi),%eax <== NOT EXECUTED 10bc03: 89 47 28 mov %eax,0x28(%edi) <== NOT EXECUTED /* * Initialize objects .. if there are any */ if ( maximum ) { 10bc06: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bc08: 75 0e jne 10bc18 <_Objects_Initialize_information+0xac> <== NOT EXECUTED _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10bc0a: 5b pop %ebx <== NOT EXECUTED 10bc0b: 5e pop %esi <== NOT EXECUTED 10bc0c: 5f pop %edi <== NOT EXECUTED 10bc0d: c9 leave <== NOT EXECUTED 10bc0e: c3 ret <== NOT EXECUTED 10bc0f: 90 nop <== NOT EXECUTED */ name_length = maximum_name_length; if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) ) name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & 10bc10: 8d 46 04 lea 0x4(%esi),%eax <== NOT EXECUTED 10bc13: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED 10bc16: eb d7 jmp 10bbef <_Objects_Initialize_information+0x83> <== NOT EXECUTED /* * Reset the maximum value. It will be updated when the information is * extended. */ information->maximum = 0; 10bc18: 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 ); 10bc1e: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10bc21: 5b pop %ebx <== NOT EXECUTED 10bc22: 5e pop %esi <== NOT EXECUTED 10bc23: 5f pop %edi <== NOT EXECUTED 10bc24: 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 ); 10bc25: e9 8e fa ff ff jmp 10b6b8 <_Objects_Extend_information> <== NOT EXECUTED 001151ec <_Objects_Name_to_id_string>: Objects_Name_or_id_lookup_errors _Objects_Name_to_id_string( Objects_Information *information, const char *name, Objects_Id *id ) { 1151ec: 55 push %ebp <== NOT EXECUTED 1151ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1151ef: 57 push %edi <== NOT EXECUTED 1151f0: 56 push %esi <== NOT EXECUTED 1151f1: 53 push %ebx <== NOT EXECUTED 1151f2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED uint32_t index; uint32_t name_length; /* ASSERT: information->is_string == TRUE */ if ( !id ) 1151f5: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 1151f8: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1151fa: 74 74 je 115270 <_Objects_Name_to_id_string+0x84> <== NOT EXECUTED return OBJECTS_INVALID_ADDRESS; if ( !name ) 1151fc: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 1151ff: 85 d2 test %edx,%edx <== NOT EXECUTED 115201: 74 4a je 11524d <_Objects_Name_to_id_string+0x61> <== NOT EXECUTED return OBJECTS_INVALID_NAME; if ( information->maximum != 0 ) { 115203: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 115206: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 115209: 66 85 c0 test %ax,%ax <== NOT EXECUTED 11520c: 74 3f je 11524d <_Objects_Name_to_id_string+0x61> <== NOT EXECUTED name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 11520e: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 115211: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 115214: 85 c0 test %eax,%eax <== NOT EXECUTED 115216: 74 35 je 11524d <_Objects_Name_to_id_string+0x61> <== NOT EXECUTED 115218: 8b 7a 1c mov 0x1c(%edx),%edi <== NOT EXECUTED 11521b: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED the_object = information->local_table[ index ]; 115220: 8b 34 9f mov (%edi,%ebx,4),%esi <== NOT EXECUTED if ( !the_object ) 115223: 85 f6 test %esi,%esi <== NOT EXECUTED 115225: 74 20 je 115247 <_Objects_Name_to_id_string+0x5b> <== NOT EXECUTED continue; if ( !the_object->name.name_p ) 115227: 8b 56 0c mov 0xc(%esi),%edx <== NOT EXECUTED 11522a: 85 d2 test %edx,%edx <== NOT EXECUTED 11522c: 74 19 je 115247 <_Objects_Name_to_id_string+0x5b> <== NOT EXECUTED continue; if (!strncmp( name, the_object->name.name_p, information->name_length)) { 11522e: 50 push %eax <== NOT EXECUTED 11522f: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 115232: 0f b7 41 3a movzwl 0x3a(%ecx),%eax <== NOT EXECUTED 115236: 50 push %eax <== NOT EXECUTED 115237: 52 push %edx <== NOT EXECUTED 115238: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11523b: e8 2c 27 00 00 call 11796c <== NOT EXECUTED 115240: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115243: 85 c0 test %eax,%eax <== NOT EXECUTED 115245: 74 15 je 11525c <_Objects_Name_to_id_string+0x70> <== NOT EXECUTED return OBJECTS_INVALID_NAME; if ( information->maximum != 0 ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 115247: 43 inc %ebx <== NOT EXECUTED 115248: 3b 5d f0 cmp -0x10(%ebp),%ebx <== NOT EXECUTED 11524b: 76 d3 jbe 115220 <_Objects_Name_to_id_string+0x34> <== NOT EXECUTED 11524d: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED } } } return OBJECTS_INVALID_NAME; } 115252: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 115255: 5b pop %ebx <== NOT EXECUTED 115256: 5e pop %esi <== NOT EXECUTED 115257: 5f pop %edi <== NOT EXECUTED 115258: c9 leave <== NOT EXECUTED 115259: c3 ret <== NOT EXECUTED 11525a: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !the_object->name.name_p ) continue; if (!strncmp( name, the_object->name.name_p, information->name_length)) { *id = the_object->id; 11525c: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 11525f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 115262: 89 02 mov %eax,(%edx) <== NOT EXECUTED 115264: 31 c0 xor %eax,%eax <== NOT EXECUTED } } } return OBJECTS_INVALID_NAME; } 115266: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 115269: 5b pop %ebx <== NOT EXECUTED 11526a: 5e pop %esi <== NOT EXECUTED 11526b: 5f pop %edi <== NOT EXECUTED 11526c: c9 leave <== NOT EXECUTED 11526d: c3 ret <== NOT EXECUTED 11526e: 66 90 xchg %ax,%ax <== NOT EXECUTED uint32_t index; uint32_t name_length; /* ASSERT: information->is_string == TRUE */ if ( !id ) 115270: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED } } } return OBJECTS_INVALID_NAME; } 115275: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 115278: 5b pop %ebx <== NOT EXECUTED 115279: 5e pop %esi <== NOT EXECUTED 11527a: 5f pop %edi <== NOT EXECUTED 11527b: c9 leave <== NOT EXECUTED 11527c: c3 ret <== NOT EXECUTED 0010bc60 <_Objects_Name_to_id_u32>: Objects_Information *information, uint32_t name, uint32_t node, Objects_Id *id ) { 10bc60: 55 push %ebp <== NOT EXECUTED 10bc61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc63: 57 push %edi <== NOT EXECUTED 10bc64: 56 push %esi <== NOT EXECUTED 10bc65: 53 push %ebx <== NOT EXECUTED 10bc66: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10bc69: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == FALSE */ if ( !id ) 10bc6c: 85 ff test %edi,%edi <== NOT EXECUTED 10bc6e: 74 5c je 10bccc <_Objects_Name_to_id_u32+0x6c> <== NOT EXECUTED return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 10bc70: 85 f6 test %esi,%esi <== NOT EXECUTED 10bc72: 74 38 je 10bcac <_Objects_Name_to_id_u32+0x4c> <== NOT EXECUTED return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10bc74: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bc77: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10bc7a: 66 85 c0 test %ax,%ax <== NOT EXECUTED 10bc7d: 74 2d je 10bcac <_Objects_Name_to_id_u32+0x4c> <== NOT EXECUTED 10bc7f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10bc82: 85 d2 test %edx,%edx <== NOT EXECUTED 10bc84: 75 32 jne 10bcb8 <_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++ ) { 10bc86: 0f b7 d8 movzwl %ax,%ebx <== NOT EXECUTED 10bc89: 85 db test %ebx,%ebx <== NOT EXECUTED 10bc8b: 74 1f je 10bcac <_Objects_Name_to_id_u32+0x4c> <== NOT EXECUTED if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10bc8d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bc90: 8b 48 1c mov 0x1c(%eax),%ecx <== NOT EXECUTED 10bc93: 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 ]; 10bc98: 8b 04 91 mov (%ecx,%edx,4),%eax <== NOT EXECUTED if ( !the_object ) 10bc9b: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc9d: 74 05 je 10bca4 <_Objects_Name_to_id_u32+0x44> <== NOT EXECUTED continue; if ( name == the_object->name.name_u32 ) { 10bc9f: 39 70 0c cmp %esi,0xc(%eax) <== NOT EXECUTED 10bca2: 74 34 je 10bcd8 <_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++ ) { 10bca4: 42 inc %edx <== NOT EXECUTED 10bca5: 39 da cmp %ebx,%edx <== NOT EXECUTED 10bca7: 76 ef jbe 10bc98 <_Objects_Name_to_id_u32+0x38> <== NOT EXECUTED 10bca9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10bcac: 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 } 10bcb1: 5b pop %ebx <== NOT EXECUTED 10bcb2: 5e pop %esi <== NOT EXECUTED 10bcb3: 5f pop %edi <== NOT EXECUTED 10bcb4: c9 leave <== NOT EXECUTED 10bcb5: c3 ret <== NOT EXECUTED 10bcb6: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10bcb8: 81 7d 10 ff ff ff 7f cmpl $0x7fffffff,0x10(%ebp) <== NOT EXECUTED 10bcbf: 74 c5 je 10bc86 <_Objects_Name_to_id_u32+0x26> <== NOT EXECUTED 10bcc1: 83 7d 10 01 cmpl $0x1,0x10(%ebp) <== NOT EXECUTED 10bcc5: 75 e5 jne 10bcac <_Objects_Name_to_id_u32+0x4c> <== NOT EXECUTED 10bcc7: eb bd jmp 10bc86 <_Objects_Name_to_id_u32+0x26> <== NOT EXECUTED 10bcc9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == FALSE */ if ( !id ) 10bccc: 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 } 10bcd1: 5b pop %ebx <== NOT EXECUTED 10bcd2: 5e pop %esi <== NOT EXECUTED 10bcd3: 5f pop %edi <== NOT EXECUTED 10bcd4: c9 leave <== NOT EXECUTED 10bcd5: c3 ret <== NOT EXECUTED 10bcd6: 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; 10bcd8: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10bcdb: 89 07 mov %eax,(%edi) <== NOT EXECUTED 10bcdd: 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 } 10bcdf: 5b pop %ebx <== NOT EXECUTED 10bce0: 5e pop %esi <== NOT EXECUTED 10bce1: 5f pop %edi <== NOT EXECUTED 10bce2: c9 leave <== NOT EXECUTED 10bce3: c3 ret <== NOT EXECUTED 0010bc2c <_Objects_Namespace_remove>: void _Objects_Namespace_remove( Objects_Information *information, Objects_Control *the_object ) { 10bc2c: 55 push %ebp <== NOT EXECUTED 10bc2d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc2f: 53 push %ebx <== NOT EXECUTED 10bc30: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bc33: 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 ) 10bc36: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bc39: 80 78 38 00 cmpb $0x0,0x38(%eax) <== NOT EXECUTED 10bc3d: 74 13 je 10bc52 <_Objects_Namespace_remove+0x26> <== NOT EXECUTED 10bc3f: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10bc42: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc44: 74 0c je 10bc52 <_Objects_Namespace_remove+0x26> <== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10bc46: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bc49: 50 push %eax <== NOT EXECUTED 10bc4a: e8 19 18 00 00 call 10d468 <_Workspace_Free> <== NOT EXECUTED 10bc4f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Clear out either format. */ the_object->name.name_p = NULL; the_object->name.name_u32 = 0; 10bc52: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED } 10bc59: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bc5c: c9 leave <== NOT EXECUTED 10bc5d: c3 ret <== NOT EXECUTED 0010c37c <_Objects_Set_name>: bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 10c37c: 55 push %ebp <== NOT EXECUTED 10c37d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c37f: 57 push %edi <== NOT EXECUTED 10c380: 56 push %esi <== NOT EXECUTED 10c381: 53 push %ebx <== NOT EXECUTED 10c382: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10c385: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10c388: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED size_t length; const char *s; s = name; length = strnlen( name, information->name_length ) + 1; 10c38b: 0f b7 43 3a movzwl 0x3a(%ebx),%eax <== NOT EXECUTED 10c38f: 50 push %eax <== NOT EXECUTED 10c390: 57 push %edi <== NOT EXECUTED 10c391: e8 4a 6a 00 00 call 112de0 <== NOT EXECUTED 10c396: 8d 70 01 lea 0x1(%eax),%esi <== NOT EXECUTED if ( information->is_string ) { 10c399: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c39c: 80 7b 38 00 cmpb $0x0,0x38(%ebx) <== NOT EXECUTED 10c3a0: 75 5a jne 10c3fc <_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( 10c3a2: 85 f6 test %esi,%esi <== NOT EXECUTED 10c3a4: 74 3e je 10c3e4 <_Objects_Set_name+0x68> <== NOT EXECUTED 10c3a6: 0f be 17 movsbl (%edi),%edx <== NOT EXECUTED 10c3a9: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10c3ac: 83 fe 01 cmp $0x1,%esi <== NOT EXECUTED 10c3af: 0f 84 ae 00 00 00 je 10c463 <_Objects_Set_name+0xe7> <== NOT EXECUTED 10c3b5: 0f be 47 01 movsbl 0x1(%edi),%eax <== NOT EXECUTED 10c3b9: c1 e0 10 shl $0x10,%eax <== NOT EXECUTED 10c3bc: 09 d0 or %edx,%eax <== NOT EXECUTED 10c3be: 83 fe 02 cmp $0x2,%esi <== NOT EXECUTED 10c3c1: 0f 84 89 00 00 00 je 10c450 <_Objects_Set_name+0xd4> <== NOT EXECUTED 10c3c7: 0f be 57 02 movsbl 0x2(%edi),%edx <== NOT EXECUTED 10c3cb: c1 e2 08 shl $0x8,%edx <== NOT EXECUTED 10c3ce: 09 c2 or %eax,%edx <== NOT EXECUTED 10c3d0: 83 fe 03 cmp $0x3,%esi <== NOT EXECUTED 10c3d3: 0f 84 83 00 00 00 je 10c45c <_Objects_Set_name+0xe0> <== NOT EXECUTED 10c3d9: 0f be 47 03 movsbl 0x3(%edi),%eax <== NOT EXECUTED 10c3dd: 09 d0 or %edx,%eax <== NOT EXECUTED 10c3df: eb 08 jmp 10c3e9 <_Objects_Set_name+0x6d> <== NOT EXECUTED 10c3e1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10c3e4: b8 20 20 20 20 mov $0x20202020,%eax <== NOT EXECUTED 10c3e9: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10c3ec: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED 10c3ef: b0 01 mov $0x1,%al <== NOT EXECUTED ); } return TRUE; } 10c3f1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c3f4: 5b pop %ebx <== NOT EXECUTED 10c3f5: 5e pop %esi <== NOT EXECUTED 10c3f6: 5f pop %edi <== NOT EXECUTED 10c3f7: c9 leave <== NOT EXECUTED 10c3f8: c3 ret <== NOT EXECUTED 10c3f9: 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 ); 10c3fc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c3ff: 56 push %esi <== NOT EXECUTED 10c400: e8 ff 17 00 00 call 10dc04 <_Workspace_Allocate> <== NOT EXECUTED 10c405: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !d ) 10c407: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c40a: 85 c0 test %eax,%eax <== NOT EXECUTED 10c40c: 74 4a je 10c458 <_Objects_Set_name+0xdc> <== NOT EXECUTED return FALSE; if ( the_object->name.name_p ) { 10c40e: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10c411: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10c414: 85 c0 test %eax,%eax <== NOT EXECUTED 10c416: 74 16 je 10c42e <_Objects_Set_name+0xb2> <== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10c418: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c41b: 50 push %eax <== NOT EXECUTED 10c41c: e8 cb 17 00 00 call 10dbec <_Workspace_Free> <== NOT EXECUTED the_object->name.name_p = NULL; 10c421: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c424: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) <== NOT EXECUTED 10c42b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } strncpy( d, name, length ); 10c42e: 50 push %eax <== NOT EXECUTED 10c42f: 56 push %esi <== NOT EXECUTED 10c430: 57 push %edi <== NOT EXECUTED 10c431: 53 push %ebx <== NOT EXECUTED 10c432: e8 21 69 00 00 call 112d58 <== NOT EXECUTED d[ length ] = '\0'; 10c437: c6 04 33 00 movb $0x0,(%ebx,%esi,1) <== NOT EXECUTED the_object->name.name_p = d; 10c43b: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10c43e: 89 5a 0c mov %ebx,0xc(%edx) <== NOT EXECUTED 10c441: b0 01 mov $0x1,%al <== NOT EXECUTED 10c443: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ); } return TRUE; } 10c446: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c449: 5b pop %ebx <== NOT EXECUTED 10c44a: 5e pop %esi <== NOT EXECUTED 10c44b: 5f pop %edi <== NOT EXECUTED 10c44c: c9 leave <== NOT EXECUTED 10c44d: c3 ret <== NOT EXECUTED 10c44e: 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( 10c450: 0d 20 20 00 00 or $0x2020,%eax <== NOT EXECUTED 10c455: eb 92 jmp 10c3e9 <_Objects_Set_name+0x6d> <== NOT EXECUTED 10c457: 90 nop <== NOT EXECUTED if ( information->is_string ) { char *d; d = _Workspace_Allocate( length ); if ( !d ) 10c458: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c45a: eb 95 jmp 10c3f1 <_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( 10c45c: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c45e: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 10c461: eb 86 jmp 10c3e9 <_Objects_Set_name+0x6d> <== NOT EXECUTED 10c463: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c465: 0d 20 20 20 00 or $0x202020,%eax <== NOT EXECUTED 10c46a: e9 7a ff ff ff jmp 10c3e9 <_Objects_Set_name+0x6d> <== NOT EXECUTED 0010bcec <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 10bcec: 55 push %ebp <== NOT EXECUTED 10bced: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bcef: 57 push %edi <== NOT EXECUTED 10bcf0: 56 push %esi <== NOT EXECUTED 10bcf1: 53 push %ebx <== NOT EXECUTED 10bcf2: 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 10bcf5: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bcf8: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10bcfb: 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; 10bcfe: 8b 4a 14 mov 0x14(%edx),%ecx <== NOT EXECUTED 10bd01: 0f b7 42 10 movzwl 0x10(%edx),%eax <== NOT EXECUTED 10bd05: 29 f0 sub %esi,%eax <== NOT EXECUTED 10bd07: 31 d2 xor %edx,%edx <== NOT EXECUTED 10bd09: f7 f1 div %ecx <== NOT EXECUTED for ( block = 0; block < block_count; block++ ) { 10bd0b: 85 c0 test %eax,%eax <== NOT EXECUTED 10bd0d: 74 24 je 10bd33 <_Objects_Shrink_information+0x47> <== NOT EXECUTED if ( information->inactive_per_block[ block ] == information->allocation_size ) { 10bd0f: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bd12: 8b 5a 30 mov 0x30(%edx),%ebx <== NOT EXECUTED 10bd15: 3b 0b cmp (%ebx),%ecx <== NOT EXECUTED 10bd17: 74 22 je 10bd3b <_Objects_Shrink_information+0x4f> <== NOT EXECUTED information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; return; 10bd19: 31 d2 xor %edx,%edx <== NOT EXECUTED 10bd1b: eb 11 jmp 10bd2e <_Objects_Shrink_information+0x42> <== NOT EXECUTED 10bd1d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } index_base += information->allocation_size; 10bd20: 01 ce add %ecx,%esi <== NOT EXECUTED 10bd22: 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 ) { 10bd29: 3b 0c 93 cmp (%ebx,%edx,4),%ecx <== NOT EXECUTED 10bd2c: 74 12 je 10bd40 <_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++ ) { 10bd2e: 42 inc %edx <== NOT EXECUTED 10bd2f: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10bd31: 77 ed ja 10bd20 <_Objects_Shrink_information+0x34> <== NOT EXECUTED return; } index_base += information->allocation_size; } } 10bd33: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bd36: 5b pop %ebx <== NOT EXECUTED 10bd37: 5e pop %esi <== NOT EXECUTED 10bd38: 5f pop %edi <== NOT EXECUTED 10bd39: c9 leave <== NOT EXECUTED 10bd3a: 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 ) { 10bd3b: 31 ff xor %edi,%edi <== NOT EXECUTED 10bd3d: 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; 10bd40: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bd43: 8b 4b 20 mov 0x20(%ebx),%ecx <== NOT EXECUTED 10bd46: eb 26 jmp 10bd6e <_Objects_Shrink_information+0x82> <== NOT EXECUTED */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 10bd48: 89 f0 mov %esi,%eax <== NOT EXECUTED 10bd4a: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bd4d: 03 43 14 add 0x14(%ebx),%eax <== NOT EXECUTED 10bd50: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10bd52: 76 24 jbe 10bd78 <_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, 10bd54: 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 ); 10bd56: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bd59: 51 push %ecx <== NOT EXECUTED 10bd5a: e8 59 39 00 00 call 10f6b8 <_Chain_Extract> <== NOT EXECUTED 10bd5f: 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 ) ); 10bd62: 85 db test %ebx,%ebx <== NOT EXECUTED 10bd64: 74 1a je 10bd80 <_Objects_Shrink_information+0x94> <== NOT EXECUTED 10bd66: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10bd68: 85 c0 test %eax,%eax <== NOT EXECUTED 10bd6a: 74 14 je 10bd80 <_Objects_Shrink_information+0x94> <== NOT EXECUTED 10bd6c: 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 10bd6e: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10bd71: 0f b7 d0 movzwl %ax,%edx <== NOT EXECUTED */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 10bd74: 39 f2 cmp %esi,%edx <== NOT EXECUTED 10bd76: 73 d0 jae 10bd48 <_Objects_Shrink_information+0x5c> <== NOT EXECUTED the_object = NULL; _Chain_Extract( &extract_me->Node ); } else { the_object = (Objects_Control *) the_object->Node.next; 10bd78: 8b 19 mov (%ecx),%ebx <== NOT EXECUTED } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 10bd7a: 85 db test %ebx,%ebx <== NOT EXECUTED 10bd7c: 75 e8 jne 10bd66 <_Objects_Shrink_information+0x7a> <== NOT EXECUTED 10bd7e: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); 10bd80: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bd83: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bd86: 8b 42 34 mov 0x34(%edx),%eax <== NOT EXECUTED 10bd89: ff 34 38 pushl (%eax,%edi,1) <== NOT EXECUTED 10bd8c: e8 d7 16 00 00 call 10d468 <_Workspace_Free> <== NOT EXECUTED information->object_blocks[ block ] = NULL; 10bd91: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bd94: 8b 43 34 mov 0x34(%ebx),%eax <== NOT EXECUTED 10bd97: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1) <== NOT EXECUTED information->inactive_per_block[ block ] = 0; 10bd9e: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10bda1: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1) <== NOT EXECUTED information->inactive -= information->allocation_size; 10bda8: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10bdab: 66 29 43 2c sub %ax,0x2c(%ebx) <== NOT EXECUTED 10bdaf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return; } index_base += information->allocation_size; } } 10bdb2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bdb5: 5b pop %ebx <== NOT EXECUTED 10bdb6: 5e pop %esi <== NOT EXECUTED 10bdb7: 5f pop %edi <== NOT EXECUTED 10bdb8: c9 leave <== NOT EXECUTED 10bdb9: c3 ret <== NOT EXECUTED 0010ab14 <_POSIX_API_Initialize>: void _POSIX_API_Initialize( rtems_configuration_table *configuration_table ) { 10ab14: 55 push %ebp <== NOT EXECUTED 10ab15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ab17: 53 push %ebx <== NOT EXECUTED 10ab18: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED /* XXX need to assert here based on size assumptions */ assert( sizeof(pthread_t) == sizeof(Objects_Id) ); api_configuration = configuration_table->POSIX_api_configuration; 10ab1b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ab1e: 8b 58 44 mov 0x44(%eax),%ebx <== NOT EXECUTED if ( !api_configuration ) 10ab21: 85 db test %ebx,%ebx <== NOT EXECUTED 10ab23: 74 7f je 10aba4 <_POSIX_API_Initialize+0x90> <== NOT EXECUTED api_configuration = &_POSIX_Default_configuration; _Objects_Information_table[OBJECTS_POSIX_API] = _POSIX_Objects; 10ab25: c7 05 98 f7 11 00 e0 movl $0x11fce0,0x11f798 <== NOT EXECUTED 10ab2c: fc 11 00 <== NOT EXECUTED _POSIX_signals_Manager_Initialization( 10ab2f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab32: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 10ab35: e8 4a 42 00 00 call 10ed84 <_POSIX_signals_Manager_Initialization> <== NOT EXECUTED api_configuration->maximum_queued_signals ); _POSIX_Threads_Manager_initialization( 10ab3a: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ab3d: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10ab40: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10ab43: ff 33 pushl (%ebx) <== NOT EXECUTED 10ab45: e8 ce 43 00 00 call 10ef18 <_POSIX_Threads_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_threads, api_configuration->number_of_initialization_threads, api_configuration->User_initialization_threads_table ); _POSIX_Condition_variables_Manager_initialization( 10ab4a: 58 pop %eax <== NOT EXECUTED 10ab4b: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10ab4e: e8 21 41 00 00 call 10ec74 <_POSIX_Condition_variables_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_condition_variables ); _POSIX_Key_Manager_initialization( api_configuration->maximum_keys ); 10ab53: 58 pop %eax <== NOT EXECUTED 10ab54: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 10ab57: e8 40 41 00 00 call 10ec9c <_POSIX_Key_Manager_initialization> <== NOT EXECUTED _POSIX_Mutex_Manager_initialization( 10ab5c: 58 pop %eax <== NOT EXECUTED 10ab5d: ff 73 04 pushl 0x4(%ebx) <== NOT EXECUTED 10ab60: e8 a7 41 00 00 call 10ed0c <_POSIX_Mutex_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_mutexes ); _POSIX_Message_queue_Manager_initialization( 10ab65: 58 pop %eax <== NOT EXECUTED 10ab66: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10ab69: e8 56 41 00 00 call 10ecc4 <_POSIX_Message_queue_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_message_queues ); _POSIX_Semaphore_Manager_initialization( 10ab6e: 58 pop %eax <== NOT EXECUTED 10ab6f: ff 73 1c pushl 0x1c(%ebx) <== NOT EXECUTED 10ab72: e8 c5 46 00 00 call 10f23c <_POSIX_Semaphore_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_semaphores ); _POSIX_Timer_Manager_initialization( api_configuration->maximum_timers ); 10ab77: 59 pop %ecx <== NOT EXECUTED 10ab78: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10ab7b: e8 94 46 00 00 call 10f214 <_POSIX_Timer_Manager_initialization> <== NOT EXECUTED _POSIX_Barrier_Manager_initialization( api_configuration->maximum_barriers ); 10ab80: 5a pop %edx <== NOT EXECUTED 10ab81: ff 73 20 pushl 0x20(%ebx) <== NOT EXECUTED 10ab84: e8 ab 41 00 00 call 10ed34 <_POSIX_Barrier_Manager_initialization> <== NOT EXECUTED _POSIX_RWLock_Manager_initialization( api_configuration->maximum_rwlocks ); 10ab89: 58 pop %eax <== NOT EXECUTED 10ab8a: ff 73 24 pushl 0x24(%ebx) <== NOT EXECUTED 10ab8d: e8 ca 41 00 00 call 10ed5c <_POSIX_RWLock_Manager_initialization> <== NOT EXECUTED _POSIX_Spinlock_Manager_initialization(api_configuration->maximum_spinlocks); 10ab92: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ab95: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 10ab98: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10ab9b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ab9e: c9 leave <== NOT EXECUTED _POSIX_Barrier_Manager_initialization( api_configuration->maximum_barriers ); _POSIX_RWLock_Manager_initialization( api_configuration->maximum_rwlocks ); _POSIX_Spinlock_Manager_initialization(api_configuration->maximum_spinlocks); 10ab9f: e9 38 43 00 00 jmp 10eedc <_POSIX_Spinlock_Manager_initialization> <== NOT EXECUTED /* XXX need to assert here based on size assumptions */ assert( sizeof(pthread_t) == sizeof(Objects_Id) ); api_configuration = configuration_table->POSIX_api_configuration; if ( !api_configuration ) 10aba4: bb a0 90 11 00 mov $0x1190a0,%ebx <== NOT EXECUTED 10aba9: e9 77 ff ff ff jmp 10ab25 <_POSIX_API_Initialize+0x11> <== NOT EXECUTED 0010c0e4 <_POSIX_Absolute_timeout_to_ticks>: */ POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks( const struct timespec *abstime, Watchdog_Interval *ticks_out ) { 10c0e4: 55 push %ebp <== NOT EXECUTED 10c0e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c0e7: 57 push %edi <== NOT EXECUTED 10c0e8: 56 push %esi <== NOT EXECUTED 10c0e9: 53 push %ebx <== NOT EXECUTED 10c0ea: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 10c0ed: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED /* * Make sure there is always a value returned. */ *ticks_out = 0; 10c0f0: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c0f3: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED /* * Is the absolute time even valid? */ if ( !_Timespec_Is_valid(abstime) ) 10c0f9: 56 push %esi <== NOT EXECUTED 10c0fa: e8 bd 3e 00 00 call 10ffbc <_Timespec_Is_valid> <== NOT EXECUTED 10c0ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c102: 84 c0 test %al,%al <== NOT EXECUTED 10c104: 75 0a jne 10c110 <_POSIX_Absolute_timeout_to_ticks+0x2c> <== NOT EXECUTED 10c106: 31 c0 xor %eax,%eax <== NOT EXECUTED /* * This is the case we were expecting and it took this long to * get here. */ return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE; } 10c108: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c10b: 5b pop %ebx <== NOT EXECUTED 10c10c: 5e pop %esi <== NOT EXECUTED 10c10d: 5f pop %edi <== NOT EXECUTED 10c10e: c9 leave <== NOT EXECUTED 10c10f: c3 ret <== NOT EXECUTED return POSIX_ABSOLUTE_TIMEOUT_INVALID; /* * Is the absolute time in the past? */ _TOD_Get( ¤t_time ); 10c110: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c113: 8d 7d ec lea -0x14(%ebp),%edi <== NOT EXECUTED 10c116: 57 push %edi <== NOT EXECUTED 10c117: e8 1c 21 00 00 call 10e238 <_TOD_Get> <== NOT EXECUTED if ( _Timespec_Less_than( abstime, ¤t_time ) ) 10c11c: 5a pop %edx <== NOT EXECUTED 10c11d: 59 pop %ecx <== NOT EXECUTED 10c11e: 57 push %edi <== NOT EXECUTED 10c11f: 56 push %esi <== NOT EXECUTED 10c120: e8 bf 3e 00 00 call 10ffe4 <_Timespec_Less_than> <== NOT EXECUTED 10c125: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c128: 84 c0 test %al,%al <== NOT EXECUTED 10c12a: 74 10 je 10c13c <_POSIX_Absolute_timeout_to_ticks+0x58> <== NOT EXECUTED 10c12c: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED /* * This is the case we were expecting and it took this long to * get here. */ return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE; } 10c131: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c134: 5b pop %ebx <== NOT EXECUTED 10c135: 5e pop %esi <== NOT EXECUTED 10c136: 5f pop %edi <== NOT EXECUTED 10c137: c9 leave <== NOT EXECUTED 10c138: c3 ret <== NOT EXECUTED 10c139: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST; /* * How long until the requested absolute time? */ _Timespec_Subtract( ¤t_time, abstime, &difference ); 10c13c: 50 push %eax <== NOT EXECUTED 10c13d: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED 10c140: 53 push %ebx <== NOT EXECUTED 10c141: 56 push %esi <== NOT EXECUTED 10c142: 57 push %edi <== NOT EXECUTED 10c143: e8 c0 3e 00 00 call 110008 <_Timespec_Subtract> <== NOT EXECUTED /* * Internally the SuperCore uses ticks, so convert to them. */ *ticks_out = _Timespec_To_ticks( &difference ); 10c148: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10c14b: e8 f4 3e 00 00 call 110044 <_Timespec_To_ticks> <== NOT EXECUTED 10c150: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10c153: 89 02 mov %eax,(%edx) <== NOT EXECUTED /* * If the difference was 0, then the future is now. It is so bright * we better wear shades. */ if ( !*ticks_out ) 10c155: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c158: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10c15b: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10c15d: 83 c0 03 add $0x3,%eax <== NOT EXECUTED /* * This is the case we were expecting and it took this long to * get here. */ return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE; } 10c160: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c163: 5b pop %ebx <== NOT EXECUTED 10c164: 5e pop %esi <== NOT EXECUTED 10c165: 5f pop %edi <== NOT EXECUTED 10c166: c9 leave <== NOT EXECUTED 10c167: c3 ret <== NOT EXECUTED 0010ed34 <_POSIX_Barrier_Manager_initialization>: */ void _POSIX_Barrier_Manager_initialization( uint32_t maximum_barriers ) { 10ed34: 55 push %ebp <== NOT EXECUTED 10ed35: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ed37: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ed3a: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10ed3f: 6a 01 push $0x1 <== NOT EXECUTED 10ed41: 6a 5c push $0x5c <== NOT EXECUTED 10ed43: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ed46: 6a 0a push $0xa <== NOT EXECUTED 10ed48: 6a 03 push $0x3 <== NOT EXECUTED 10ed4a: 68 00 fc 11 00 push $0x11fc00 <== NOT EXECUTED 10ed4f: e8 18 ce ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10ed54: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ed57: c9 leave <== NOT EXECUTED 10ed58: c3 ret <== NOT EXECUTED 001101f4 <_POSIX_Barrier_Translate_core_barrier_return_code>: int _POSIX_Barrier_Translate_core_barrier_return_code( CORE_barrier_Status the_barrier_status ) { 1101f4: 55 push %ebp <== NOT EXECUTED 1101f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1101f7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1101fa: 8b 04 85 30 ad 11 00 mov 0x11ad30(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_barrier_status > CORE_BARRIER_STATUS_LAST ) return EINVAL; #endif return _POSIX_Barrier_Return_codes[the_barrier_status]; } 110201: c9 leave <== NOT EXECUTED 110202: c3 ret <== NOT EXECUTED 0010add0 <_POSIX_Condition_variables_Get>: POSIX_Condition_variables_Control *_POSIX_Condition_variables_Get ( pthread_cond_t *cond, Objects_Locations *location ) { 10add0: 55 push %ebp <== NOT EXECUTED 10add1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10add3: 53 push %ebx <== NOT EXECUTED 10add4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10add7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 10adda: 85 db test %ebx,%ebx <== NOT EXECUTED 10addc: 74 36 je 10ae14 <_POSIX_Condition_variables_Get+0x44> <== NOT EXECUTED *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 10adde: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10ade0: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10ade3: 74 17 je 10adfc <_POSIX_Condition_variables_Get+0x2c> <== NOT EXECUTED /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 10ade5: 52 push %edx <== NOT EXECUTED 10ade6: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10ade9: 50 push %eax <== NOT EXECUTED 10adea: 68 00 2c 12 00 push $0x122c00 <== NOT EXECUTED 10adef: e8 cc 2d 00 00 call 10dbc0 <_Objects_Get> <== NOT EXECUTED 10adf4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Objects_Get( &_POSIX_Condition_variables_Information, *id, location ); } 10adf7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10adfa: c9 leave <== NOT EXECUTED 10adfb: c3 ret <== NOT EXECUTED if ( *id == PTHREAD_COND_INITIALIZER ) { /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 10adfc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10adff: 6a 00 push $0x0 <== NOT EXECUTED 10ae01: 53 push %ebx <== NOT EXECUTED 10ae02: e8 1d 00 00 00 call 10ae24 <== NOT EXECUTED if ( status ) { 10ae07: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae0a: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae0c: 75 06 jne 10ae14 <_POSIX_Condition_variables_Get+0x44> <== NOT EXECUTED 10ae0e: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10ae10: eb d3 jmp 10ade5 <_POSIX_Condition_variables_Get+0x15> <== NOT EXECUTED 10ae12: 66 90 xchg %ax,%ax <== NOT EXECUTED *location = OBJECTS_ERROR; 10ae14: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ae17: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10ae1d: 31 c0 xor %eax,%eax 10ae1f: eb d6 jmp 10adf7 <_POSIX_Condition_variables_Get+0x27> <== NOT EXECUTED 0010ec74 <_POSIX_Condition_variables_Manager_initialization>: */ void _POSIX_Condition_variables_Manager_initialization( uint32_t maximum_condition_variables ) { 10ec74: 55 push %ebp <== NOT EXECUTED 10ec75: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ec77: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ec7a: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10ec7f: 6a 01 push $0x1 <== NOT EXECUTED 10ec81: 6a 58 push $0x58 <== NOT EXECUTED 10ec83: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ec86: 6a 08 push $0x8 <== NOT EXECUTED 10ec88: 6a 03 push $0x3 <== NOT EXECUTED 10ec8a: 68 a0 fc 11 00 push $0x11fca0 <== NOT EXECUTED 10ec8f: e8 d8 ce ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10ec94: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ec97: c9 leave <== NOT EXECUTED 10ec98: c3 ret <== NOT EXECUTED 0010aeec <_POSIX_Condition_variables_Signal_support>: int _POSIX_Condition_variables_Signal_support( pthread_cond_t *cond, bool is_broadcast ) { 10aeec: 55 push %ebp <== NOT EXECUTED 10aeed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aeef: 56 push %esi <== NOT EXECUTED 10aef0: 53 push %ebx <== NOT EXECUTED 10aef1: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 10aef4: 8a 45 0c mov 0xc(%ebp),%al <== NOT EXECUTED 10aef7: 88 45 e7 mov %al,-0x19(%ebp) <== NOT EXECUTED register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; Thread_Control *the_thread; the_cond = _POSIX_Condition_variables_Get( cond, &location ); 10aefa: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10aefd: 50 push %eax <== NOT EXECUTED 10aefe: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10af01: e8 ca fe ff ff call 10add0 <_POSIX_Condition_variables_Get> <== NOT EXECUTED 10af06: 89 c6 mov %eax,%esi <== NOT EXECUTED switch ( location ) { 10af08: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af0b: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 10af0e: 85 c0 test %eax,%eax <== NOT EXECUTED 10af10: 74 0e je 10af20 <_POSIX_Condition_variables_Signal_support+0x34> <== NOT EXECUTED 10af12: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10af17: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10af1a: 5b pop %ebx <== NOT EXECUTED 10af1b: 5e pop %esi <== NOT EXECUTED 10af1c: c9 leave <== NOT EXECUTED 10af1d: c3 ret <== NOT EXECUTED 10af1e: 66 90 xchg %ax,%ax <== NOT EXECUTED the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { case OBJECTS_LOCAL: do { the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue ); 10af20: 8d 5e 18 lea 0x18(%esi),%ebx <== NOT EXECUTED 10af23: eb 0d jmp 10af32 <_POSIX_Condition_variables_Signal_support+0x46> <== NOT EXECUTED 10af25: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !the_thread ) the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; } while ( is_broadcast && the_thread ); 10af28: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) <== NOT EXECUTED 10af2c: 74 22 je 10af50 <_POSIX_Condition_variables_Signal_support+0x64> <== NOT EXECUTED 10af2e: 85 c0 test %eax,%eax <== NOT EXECUTED 10af30: 74 1e je 10af50 <_POSIX_Condition_variables_Signal_support+0x64> <== NOT EXECUTED the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { case OBJECTS_LOCAL: do { the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue ); 10af32: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af35: 53 push %ebx <== NOT EXECUTED 10af36: e8 4d 38 00 00 call 10e788 <_Thread_queue_Dequeue> <== NOT EXECUTED if ( !the_thread ) 10af3b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af3e: 85 c0 test %eax,%eax <== NOT EXECUTED 10af40: 75 e6 jne 10af28 <_POSIX_Condition_variables_Signal_support+0x3c> <== NOT EXECUTED the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 10af42: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED } while ( is_broadcast && the_thread ); 10af49: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) <== NOT EXECUTED 10af4d: 75 df jne 10af2e <_POSIX_Condition_variables_Signal_support+0x42> <== NOT EXECUTED 10af4f: 90 nop <== NOT EXECUTED _Thread_Enable_dispatch(); 10af50: e8 af 34 00 00 call 10e404 <_Thread_Enable_dispatch> <== NOT EXECUTED 10af55: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10af57: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10af5a: 5b pop %ebx <== NOT EXECUTED 10af5b: 5e pop %esi <== NOT EXECUTED 10af5c: c9 leave <== NOT EXECUTED 10af5d: c3 ret <== NOT EXECUTED 0010afcc <_POSIX_Condition_variables_Wait_support>: pthread_cond_t *cond, pthread_mutex_t *mutex, Watchdog_Interval timeout, bool already_timedout ) { 10afcc: 55 push %ebp <== NOT EXECUTED 10afcd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10afcf: 56 push %esi <== NOT EXECUTED 10afd0: 53 push %ebx <== NOT EXECUTED 10afd1: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 10afd4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10afd7: 8a 45 14 mov 0x14(%ebp),%al <== NOT EXECUTED 10afda: 88 45 e7 mov %al,-0x19(%ebp) <== NOT EXECUTED register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; int status; int mutex_status; if ( !_POSIX_Mutex_Get( mutex, &location ) ) { 10afdd: 8d 5d f4 lea -0xc(%ebp),%ebx <== NOT EXECUTED 10afe0: 53 push %ebx <== NOT EXECUTED 10afe1: 56 push %esi <== NOT EXECUTED 10afe2: e8 b1 01 00 00 call 10b198 <_POSIX_Mutex_Get> <== NOT EXECUTED 10afe7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10afea: 85 c0 test %eax,%eax <== NOT EXECUTED 10afec: 74 6e je 10b05c <_POSIX_Condition_variables_Wait_support+0x90> <== NOT EXECUTED 10afee: a1 18 27 12 00 mov 0x122718,%eax <== NOT EXECUTED 10aff3: 48 dec %eax <== NOT EXECUTED 10aff4: a3 18 27 12 00 mov %eax,0x122718 <== NOT EXECUTED return EINVAL; } _Thread_Unnest_dispatch(); the_cond = _POSIX_Condition_variables_Get( cond, &location ); 10aff9: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10affc: 53 push %ebx <== NOT EXECUTED 10affd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b000: e8 cb fd ff ff call 10add0 <_POSIX_Condition_variables_Get> <== NOT EXECUTED 10b005: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch ( location ) { 10b007: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b00a: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 10b00d: 85 d2 test %edx,%edx <== NOT EXECUTED 10b00f: 75 4b jne 10b05c <_POSIX_Condition_variables_Wait_support+0x90> <== NOT EXECUTED case OBJECTS_LOCAL: if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) { 10b011: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10b014: 85 c0 test %eax,%eax <== NOT EXECUTED 10b016: 74 18 je 10b030 <_POSIX_Condition_variables_Wait_support+0x64> <== NOT EXECUTED 10b018: 3b 06 cmp (%esi),%eax <== NOT EXECUTED 10b01a: 74 14 je 10b030 <_POSIX_Condition_variables_Wait_support+0x64> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b01c: e8 e3 33 00 00 call 10e404 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b021: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10b026: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b028: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b02b: 5b pop %ebx <== NOT EXECUTED 10b02c: 5e pop %esi <== NOT EXECUTED 10b02d: c9 leave <== NOT EXECUTED 10b02e: c3 ret <== NOT EXECUTED 10b02f: 90 nop <== NOT EXECUTED if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) { _Thread_Enable_dispatch(); return EINVAL; } (void) pthread_mutex_unlock( mutex ); 10b030: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b033: 56 push %esi <== NOT EXECUTED 10b034: e8 77 03 00 00 call 10b3b0 <== NOT EXECUTED _Thread_Enable_dispatch(); return EINVAL; } */ if ( !already_timedout ) { 10b039: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b03c: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) <== NOT EXECUTED 10b040: 74 2a je 10b06c <_POSIX_Condition_variables_Wait_support+0xa0> <== NOT EXECUTED status = _Thread_Executing->Wait.return_code; if ( status && status != ETIMEDOUT ) return status; } else { _Thread_Enable_dispatch(); 10b042: e8 bd 33 00 00 call 10e404 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b047: bb 74 00 00 00 mov $0x74,%ebx <== NOT EXECUTED /* * When we get here the dispatch disable level is 0. */ mutex_status = pthread_mutex_lock( mutex ); 10b04c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b04f: 56 push %esi <== NOT EXECUTED 10b050: e8 d3 02 00 00 call 10b328 <== NOT EXECUTED if ( mutex_status ) 10b055: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b058: 85 c0 test %eax,%eax <== NOT EXECUTED 10b05a: 74 05 je 10b061 <_POSIX_Condition_variables_Wait_support+0x95> <== NOT EXECUTED 10b05c: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10b061: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b063: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b066: 5b pop %ebx <== NOT EXECUTED 10b067: 5e pop %esi <== NOT EXECUTED 10b068: c9 leave <== NOT EXECUTED 10b069: c3 ret <== NOT EXECUTED 10b06a: 66 90 xchg %ax,%ax <== NOT EXECUTED return EINVAL; } */ if ( !already_timedout ) { the_cond->Mutex = *mutex; 10b06c: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10b06e: 89 43 14 mov %eax,0x14(%ebx) <== 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 10b071: c7 43 48 01 00 00 00 movl $0x1,0x48(%ebx) <== NOT EXECUTED _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 10b078: 8b 15 dc 27 12 00 mov 0x1227dc,%edx <== NOT EXECUTED 10b07e: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED _Thread_Executing->Wait.queue = &the_cond->Wait_queue; 10b085: 8d 4b 18 lea 0x18(%ebx),%ecx <== NOT EXECUTED 10b088: 89 4a 44 mov %ecx,0x44(%edx) <== NOT EXECUTED _Thread_Executing->Wait.id = *cond; 10b08b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b08e: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10b090: 89 42 20 mov %eax,0x20(%edx) <== NOT EXECUTED _Thread_queue_Enqueue( &the_cond->Wait_queue, timeout ); 10b093: 50 push %eax <== NOT EXECUTED 10b094: 68 6c ec 10 00 push $0x10ec6c <== NOT EXECUTED 10b099: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10b09c: 51 push %ecx <== NOT EXECUTED 10b09d: e8 22 38 00 00 call 10e8c4 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b0a2: e8 5d 33 00 00 call 10e404 <_Thread_Enable_dispatch> <== NOT EXECUTED /* * Switch ourself out because we blocked as a result of the * _Thread_queue_Enqueue. */ status = _Thread_Executing->Wait.return_code; 10b0a7: a1 dc 27 12 00 mov 0x1227dc,%eax <== NOT EXECUTED 10b0ac: 8b 58 34 mov 0x34(%eax),%ebx <== NOT EXECUTED if ( status && status != ETIMEDOUT ) 10b0af: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b0b2: 85 db test %ebx,%ebx <== NOT EXECUTED 10b0b4: 74 96 je 10b04c <_POSIX_Condition_variables_Wait_support+0x80> <== NOT EXECUTED 10b0b6: 83 fb 74 cmp $0x74,%ebx <== NOT EXECUTED 10b0b9: 75 a6 jne 10b061 <_POSIX_Condition_variables_Wait_support+0x95> <== NOT EXECUTED 10b0bb: eb 8f jmp 10b04c <_POSIX_Condition_variables_Wait_support+0x80> <== NOT EXECUTED 0010ec9c <_POSIX_Key_Manager_initialization>: */ void _POSIX_Key_Manager_initialization( uint32_t maximum_keys ) { 10ec9c: 55 push %ebp <== NOT EXECUTED 10ec9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ec9f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10eca2: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10eca7: 6a 01 push $0x1 <== NOT EXECUTED 10eca9: 6a 2c push $0x2c <== NOT EXECUTED 10ecab: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ecae: 6a 02 push $0x2 <== NOT EXECUTED 10ecb0: 6a 03 push $0x3 <== NOT EXECUTED 10ecb2: 68 60 fc 11 00 push $0x11fc60 <== NOT EXECUTED 10ecb7: e8 b0 ce ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10ecbc: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ecbf: c9 leave <== NOT EXECUTED 10ecc0: c3 ret <== NOT EXECUTED 001104a8 <_POSIX_Keys_Run_destructors>: */ void _POSIX_Keys_Run_destructors( Thread_Control *thread ) { 1104a8: 55 push %ebp <== NOT EXECUTED 1104a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1104ab: 57 push %edi <== NOT EXECUTED 1104ac: 56 push %esi <== NOT EXECUTED 1104ad: 53 push %ebx <== NOT EXECUTED 1104ae: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED uint32_t iterations; bool are_all_null; POSIX_Keys_Control *the_key; void *value; thread_index = _Objects_Get_index( thread->Object.id ); 1104b1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1104b4: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 1104b7: 89 c2 mov %eax,%edx <== NOT EXECUTED 1104b9: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 1104bc: 83 e2 07 and $0x7,%edx <== NOT EXECUTED 1104bf: 8b 0d 70 fc 11 00 mov 0x11fc70,%ecx <== NOT EXECUTED the_key = (POSIX_Keys_Control *) _POSIX_Keys_Information.local_table[ index ]; if ( the_key && the_key->is_active && the_key->destructor ) { value = the_key->Values[ thread_api ][ thread_index ]; 1104c5: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 1104ca: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 1104cd: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 1104d0: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) <== NOT EXECUTED 1104d7: 8d 7a 04 lea 0x4(%edx),%edi <== NOT EXECUTED for ( ; ; ) { are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { 1104da: 66 85 c9 test %cx,%cx <== NOT EXECUTED 1104dd: 74 68 je 110547 <_POSIX_Keys_Run_destructors+0x9f> <== NOT EXECUTED 1104df: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 1104e4: c6 45 f3 01 movb $0x1,-0xd(%ebp) <== NOT EXECUTED the_key = (POSIX_Keys_Control *) 1104e8: a1 7c fc 11 00 mov 0x11fc7c,%eax <== NOT EXECUTED 1104ed: 8b 1c b0 mov (%eax,%esi,4),%ebx <== NOT EXECUTED _POSIX_Keys_Information.local_table[ index ]; if ( the_key && the_key->is_active && the_key->destructor ) { 1104f0: 85 db test %ebx,%ebx <== NOT EXECUTED 1104f2: 74 36 je 11052a <_POSIX_Keys_Run_destructors+0x82> <== NOT EXECUTED 1104f4: 80 7b 10 00 cmpb $0x0,0x10(%ebx) <== NOT EXECUTED 1104f8: 74 30 je 11052a <_POSIX_Keys_Run_destructors+0x82> <== NOT EXECUTED 1104fa: 8b 53 14 mov 0x14(%ebx),%edx <== NOT EXECUTED 1104fd: 85 d2 test %edx,%edx <== NOT EXECUTED 1104ff: 74 29 je 11052a <_POSIX_Keys_Run_destructors+0x82> <== NOT EXECUTED value = the_key->Values[ thread_api ][ thread_index ]; 110501: 8b 44 bb 08 mov 0x8(%ebx,%edi,4),%eax <== NOT EXECUTED 110505: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 110508: 8b 04 08 mov (%eax,%ecx,1),%eax <== NOT EXECUTED if ( value ) { 11050b: 85 c0 test %eax,%eax <== NOT EXECUTED 11050d: 74 1b je 11052a <_POSIX_Keys_Run_destructors+0x82> <== NOT EXECUTED (*the_key->destructor)( value ); 11050f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110512: 50 push %eax <== NOT EXECUTED 110513: ff d2 call *%edx <== NOT EXECUTED if ( the_key->Values[ thread_api ][ thread_index ] ) 110515: 8b 44 bb 08 mov 0x8(%ebx,%edi,4),%eax <== NOT EXECUTED 110519: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11051c: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 11051f: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 110522: 85 c0 test %eax,%eax <== NOT EXECUTED 110524: 74 04 je 11052a <_POSIX_Keys_Run_destructors+0x82> <== NOT EXECUTED 110526: c6 45 f3 00 movb $0x0,-0xd(%ebp) <== NOT EXECUTED for ( ; ; ) { are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { 11052a: 46 inc %esi <== NOT EXECUTED 11052b: 8b 0d 70 fc 11 00 mov 0x11fc70,%ecx <== NOT EXECUTED 110531: 0f b7 c1 movzwl %cx,%eax <== NOT EXECUTED 110534: 39 f0 cmp %esi,%eax <== NOT EXECUTED 110536: 73 b0 jae 1104e8 <_POSIX_Keys_Run_destructors+0x40> <== NOT EXECUTED are_all_null = FALSE; } } } if ( are_all_null == TRUE ) 110538: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 11053c: 75 09 jne 110547 <_POSIX_Keys_Run_destructors+0x9f> <== NOT EXECUTED return; iterations++; 11053e: ff 45 ec incl -0x14(%ebp) <== NOT EXECUTED * loop. It seems rude to unnecessarily lock up a system. * * Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99. */ if ( iterations >= PTHREAD_DESTRUCTOR_ITERATIONS ) 110541: 83 7d ec 04 cmpl $0x4,-0x14(%ebp) <== NOT EXECUTED 110545: 75 93 jne 1104da <_POSIX_Keys_Run_destructors+0x32> <== NOT EXECUTED return; } } 110547: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11054a: 5b pop %ebx <== NOT EXECUTED 11054b: 5e pop %esi <== NOT EXECUTED 11054c: 5f pop %edi <== NOT EXECUTED 11054d: c9 leave <== NOT EXECUTED 11054e: c3 ret <== NOT EXECUTED 001141b8 <_POSIX_Message_queue_Create_support>: const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 1141b8: 55 push %ebp <== NOT EXECUTED 1141b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1141bb: 57 push %edi <== NOT EXECUTED 1141bc: 56 push %esi <== NOT EXECUTED 1141bd: 53 push %ebx <== NOT EXECUTED 1141be: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 1141c1: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED CORE_message_queue_Attributes *the_mq_attr; struct mq_attr attr; char *name; size_t n; n = strnlen( name_arg, NAME_MAX ); 1141c4: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 1141c9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1141cc: e8 cf 38 00 00 call 117aa0 <== NOT EXECUTED 1141d1: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( n > NAME_MAX ) 1141d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1141d6: 3d ff 00 00 00 cmp $0xff,%eax <== NOT EXECUTED 1141db: 0f 87 d7 00 00 00 ja 1142b8 <_POSIX_Message_queue_Create_support+0x100> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1141e1: a1 58 7c 12 00 mov 0x127c58,%eax <== NOT EXECUTED 1141e6: 40 inc %eax <== NOT EXECUTED 1141e7: a3 58 7c 12 00 mov %eax,0x127c58 <== NOT EXECUTED * but were not compared against any existing implementation for * compatibility. See README.mqueue for an example program we * think will print out the defaults. Report anything you find with it. */ if ( attr_ptr == NULL ) { 1141ec: 85 f6 test %esi,%esi <== NOT EXECUTED 1141ee: 0f 84 d4 00 00 00 je 1142c8 <_POSIX_Message_queue_Create_support+0x110> <== NOT EXECUTED attr.mq_maxmsg = 10; attr.mq_msgsize = 16; } else { if ( attr_ptr->mq_maxmsg <= 0 ){ 1141f4: 8b 56 04 mov 0x4(%esi),%edx <== NOT EXECUTED 1141f7: 85 d2 test %edx,%edx <== NOT EXECUTED 1141f9: 0f 8e 0d 01 00 00 jle 11430c <_POSIX_Message_queue_Create_support+0x154> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ 1141ff: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 114202: 85 c0 test %eax,%eax <== NOT EXECUTED 114204: 0f 8e 02 01 00 00 jle 11430c <_POSIX_Message_queue_Create_support+0x154> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } attr = *attr_ptr; 11420a: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 11420d: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 114212: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 114214: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 114217: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED 11421a: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 11421d: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus extern "C" { 114220: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114223: 68 20 80 12 00 push $0x128020 <== NOT EXECUTED 114228: e8 cf c6 ff ff call 1108fc <_Objects_Allocate> <== NOT EXECUTED 11422d: 89 c7 mov %eax,%edi <== NOT EXECUTED } the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { 11422f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114232: 85 c0 test %eax,%eax <== NOT EXECUTED 114234: 0f 84 e9 00 00 00 je 114323 <_POSIX_Message_queue_Create_support+0x16b> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq->process_shared = pshared; 11423a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11423d: 89 47 10 mov %eax,0x10(%edi) <== NOT EXECUTED the_mq->named = TRUE; 114240: c6 47 14 01 movb $0x1,0x14(%edi) <== NOT EXECUTED the_mq->open_count = 1; 114244: c7 47 18 01 00 00 00 movl $0x1,0x18(%edi) <== NOT EXECUTED the_mq->linked = TRUE; 11424b: c6 47 15 01 movb $0x1,0x15(%edi) <== NOT EXECUTED /* * Make a copy of the user's string for name just in case it was * dynamically constructed. */ name = _Workspace_Allocate(n); 11424f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114252: 53 push %ebx <== NOT EXECUTED 114253: e8 50 e6 ff ff call 1128a8 <_Workspace_Allocate> <== NOT EXECUTED 114258: 89 c6 mov %eax,%esi <== NOT EXECUTED if (!name) { 11425a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11425d: 85 c0 test %eax,%eax <== NOT EXECUTED 11425f: 0f 84 d8 00 00 00 je 11433d <_POSIX_Message_queue_Create_support+0x185> <== NOT EXECUTED _POSIX_Message_queue_Free( the_mq ); _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOMEM ); } strcpy( name, name_arg ); 114265: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114268: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11426b: 50 push %eax <== NOT EXECUTED 11426c: e8 13 34 00 00 call 117684 <== NOT EXECUTED * Note that thread blocking discipline should be based on the * current scheduling policy. */ the_mq_attr = &the_mq->Message_queue.Attributes; the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; 114271: c7 47 5c 00 00 00 00 movl $0x0,0x5c(%edi) <== NOT EXECUTED if ( ! _CORE_message_queue_Initialize( 114278: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED 11427b: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 11427e: 8d 47 5c lea 0x5c(%edi),%eax <== NOT EXECUTED 114281: 50 push %eax <== NOT EXECUTED 114282: 8d 47 1c lea 0x1c(%edi),%eax <== NOT EXECUTED 114285: 50 push %eax <== NOT EXECUTED 114286: e8 f9 0a 00 00 call 114d84 <_CORE_message_queue_Initialize> <== NOT EXECUTED 11428b: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 11428e: 84 c0 test %al,%al <== NOT EXECUTED 114290: 74 4a je 1142dc <_POSIX_Message_queue_Create_support+0x124> <== NOT EXECUTED 114292: 0f b7 57 08 movzwl 0x8(%edi),%edx <== NOT EXECUTED 114296: a1 3c 80 12 00 mov 0x12803c,%eax <== NOT EXECUTED 11429b: 89 3c 90 mov %edi,(%eax,%edx,4) <== NOT EXECUTED 11429e: 89 77 0c mov %esi,0xc(%edi) <== NOT EXECUTED &_POSIX_Message_queue_Information, &the_mq->Object, name ); *message_queue = the_mq; 1142a1: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1142a4: 89 38 mov %edi,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 1142a6: e8 dd d3 ff ff call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED 1142ab: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 1142ad: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1142b0: 5b pop %ebx <== NOT EXECUTED 1142b1: 5e pop %esi <== NOT EXECUTED 1142b2: 5f pop %edi <== NOT EXECUTED 1142b3: c9 leave <== NOT EXECUTED 1142b4: c3 ret <== NOT EXECUTED 1142b5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED struct mq_attr attr; char *name; size_t n; n = strnlen( name_arg, NAME_MAX ); if ( n > NAME_MAX ) 1142b8: b8 5b 00 00 00 mov $0x5b,%eax <== NOT EXECUTED *message_queue = the_mq; _Thread_Enable_dispatch(); return 0; } 1142bd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1142c0: 5b pop %ebx <== NOT EXECUTED 1142c1: 5e pop %esi <== NOT EXECUTED 1142c2: 5f pop %edi <== NOT EXECUTED 1142c3: c9 leave <== NOT EXECUTED 1142c4: c3 ret <== NOT EXECUTED 1142c5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * but were not compared against any existing implementation for * compatibility. See README.mqueue for an example program we * think will print out the defaults. Report anything you find with it. */ if ( attr_ptr == NULL ) { 1142c8: c7 45 dc 10 00 00 00 movl $0x10,-0x24(%ebp) <== NOT EXECUTED 1142cf: c7 45 e0 0a 00 00 00 movl $0xa,-0x20(%ebp) <== NOT EXECUTED 1142d6: e9 45 ff ff ff jmp 114220 <_POSIX_Message_queue_Create_support+0x68> <== NOT EXECUTED 1142db: 90 nop <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 1142dc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1142df: 57 push %edi <== NOT EXECUTED 1142e0: 68 20 80 12 00 push $0x128020 <== NOT EXECUTED 1142e5: e8 d2 c9 ff ff call 110cbc <_Objects_Free> <== NOT EXECUTED attr.mq_maxmsg, attr.mq_msgsize ) ) { _POSIX_Message_queue_Free( the_mq ); _Workspace_Free(name); 1142ea: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 1142ed: e8 9e e5 ff ff call 112890 <_Workspace_Free> <== NOT EXECUTED _Thread_Enable_dispatch(); 1142f2: e8 91 d3 ff ff call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); 1142f7: e8 50 22 00 00 call 11654c <__errno> <== NOT EXECUTED 1142fc: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 114302: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 114307: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11430a: eb a1 jmp 1142ad <_POSIX_Message_queue_Create_support+0xf5> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ _Thread_Enable_dispatch(); 11430c: e8 77 d3 ff ff call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 114311: e8 36 22 00 00 call 11654c <__errno> <== NOT EXECUTED 114316: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11431c: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 114321: eb 8a jmp 1142ad <_POSIX_Message_queue_Create_support+0xf5> <== NOT EXECUTED attr = *attr_ptr; } the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { _Thread_Enable_dispatch(); 114323: e8 60 d3 ff ff call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENFILE ); 114328: e8 1f 22 00 00 call 11654c <__errno> <== NOT EXECUTED 11432d: c7 00 17 00 00 00 movl $0x17,(%eax) <== NOT EXECUTED 114333: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 114338: e9 70 ff ff ff jmp 1142ad <_POSIX_Message_queue_Create_support+0xf5> <== NOT EXECUTED 11433d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114340: 57 push %edi <== NOT EXECUTED 114341: 68 20 80 12 00 push $0x128020 <== NOT EXECUTED 114346: e8 71 c9 ff ff call 110cbc <_Objects_Free> <== NOT EXECUTED */ name = _Workspace_Allocate(n); if (!name) { _POSIX_Message_queue_Free( the_mq ); _Thread_Enable_dispatch(); 11434b: e8 38 d3 ff ff call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM ); 114350: e8 f7 21 00 00 call 11654c <__errno> <== NOT EXECUTED 114355: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 11435b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 114360: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114363: e9 45 ff ff ff jmp 1142ad <_POSIX_Message_queue_Create_support+0xf5> <== NOT EXECUTED 0010d8c0 <_POSIX_Message_queue_Delete>: */ void _POSIX_Message_queue_Delete( POSIX_Message_queue_Control *the_mq ) { 10d8c0: 55 push %ebp <== NOT EXECUTED 10d8c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d8c3: 53 push %ebx <== NOT EXECUTED 10d8c4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d8c7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( !the_mq->linked && !the_mq->open_count ) { 10d8ca: 80 7b 15 00 cmpb $0x0,0x15(%ebx) <== NOT EXECUTED 10d8ce: 75 48 jne 10d918 <_POSIX_Message_queue_Delete+0x58> <== NOT EXECUTED 10d8d0: 8b 4b 18 mov 0x18(%ebx),%ecx <== NOT EXECUTED 10d8d3: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10d8d5: 75 41 jne 10d918 <_POSIX_Message_queue_Delete+0x58> <== NOT EXECUTED /* the name memory may have been freed by unlink. */ Objects_Control *the_object = &the_mq->Object; if ( the_object->name.name_p ) 10d8d7: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10d8da: 85 c0 test %eax,%eax <== NOT EXECUTED 10d8dc: 74 0c je 10d8ea <_POSIX_Message_queue_Delete+0x2a> <== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10d8de: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d8e1: 50 push %eax <== NOT EXECUTED 10d8e2: e8 a9 4f 00 00 call 112890 <_Workspace_Free> <== NOT EXECUTED 10d8e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Objects_Close( &_POSIX_Message_queue_Information, the_object ); 10d8ea: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d8ed: 53 push %ebx <== NOT EXECUTED 10d8ee: 68 20 80 12 00 push $0x128020 <== NOT EXECUTED 10d8f3: e8 84 30 00 00 call 11097c <_Objects_Close> <== NOT EXECUTED _CORE_message_queue_Close( 10d8f8: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10d8fb: 6a 05 push $0x5 <== NOT EXECUTED 10d8fd: 6a 00 push $0x0 <== NOT EXECUTED 10d8ff: 8d 43 1c lea 0x1c(%ebx),%eax <== NOT EXECUTED 10d902: 50 push %eax <== NOT EXECUTED 10d903: e8 04 26 00 00 call 10ff0c <_CORE_message_queue_Close> <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 10d908: 58 pop %eax <== NOT EXECUTED 10d909: 5a pop %edx <== NOT EXECUTED 10d90a: 53 push %ebx <== NOT EXECUTED 10d90b: 68 20 80 12 00 push $0x128020 <== NOT EXECUTED 10d910: e8 a7 33 00 00 call 110cbc <_Objects_Free> <== NOT EXECUTED 10d915: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ); _POSIX_Message_queue_Free( the_mq ); } } 10d918: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d91b: c9 leave <== NOT EXECUTED 10d91c: c3 ret <== NOT EXECUTED 0010ecc4 <_POSIX_Message_queue_Manager_initialization>: */ void _POSIX_Message_queue_Manager_initialization( uint32_t maximum_message_queues ) { 10ecc4: 55 push %ebp <== NOT EXECUTED 10ecc5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ecc7: 53 push %ebx <== NOT EXECUTED 10ecc8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10eccb: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED _Objects_Initialize_information( 10ecce: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10ecd3: 6a 01 push $0x1 <== NOT EXECUTED 10ecd5: 68 a4 00 00 00 push $0xa4 <== NOT EXECUTED 10ecda: 53 push %ebx <== NOT EXECUTED 10ecdb: 6a 05 push $0x5 <== NOT EXECUTED 10ecdd: 6a 03 push $0x3 <== NOT EXECUTED 10ecdf: 68 80 fb 11 00 push $0x11fb80 <== NOT EXECUTED 10ece4: e8 83 ce ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); _Objects_Initialize_information( 10ece9: 83 c4 1c add $0x1c,%esp <== NOT EXECUTED 10ecec: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10ecf1: 6a 01 push $0x1 <== NOT EXECUTED 10ecf3: 6a 18 push $0x18 <== NOT EXECUTED 10ecf5: 53 push %ebx <== NOT EXECUTED 10ecf6: 6a 04 push $0x4 <== NOT EXECUTED 10ecf8: 6a 03 push $0x3 <== NOT EXECUTED 10ecfa: 68 20 fd 11 00 push $0x11fd20 <== NOT EXECUTED 10ecff: e8 68 ce ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10ed04: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ed07: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ed0a: c9 leave <== NOT EXECUTED 10ed0b: c3 ret <== NOT EXECUTED 00114368 <_POSIX_Message_queue_Name_to_id>: int _POSIX_Message_queue_Name_to_id( const char *name, Objects_Id *id ) { 114368: 55 push %ebp <== NOT EXECUTED 114369: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11436b: 57 push %edi <== NOT EXECUTED 11436c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 11436f: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; if ( !name ) 114372: 85 d2 test %edx,%edx <== NOT EXECUTED 114374: 74 05 je 11437b <_POSIX_Message_queue_Name_to_id+0x13> <== NOT EXECUTED return EINVAL; if ( !name[0] ) 114376: 80 3a 00 cmpb $0x0,(%edx) <== NOT EXECUTED 114379: 75 0d jne 114388 <_POSIX_Message_queue_Name_to_id+0x20> <== NOT EXECUTED return ENAMETOOLONG; status = _Objects_Name_to_id_string( &_POSIX_Message_queue_Information, name, id ); if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) 11437b: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED return 0; return ENOENT; } 114380: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 114383: c9 leave <== NOT EXECUTED 114384: c3 ret <== NOT EXECUTED 114385: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return EINVAL; if ( !name[0] ) return EINVAL; if( strlen(name) > PATH_MAX ) 114388: 31 c0 xor %eax,%eax <== NOT EXECUTED 11438a: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 11438f: 89 d7 mov %edx,%edi <== NOT EXECUTED 114391: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 114393: f7 d1 not %ecx <== NOT EXECUTED 114395: 49 dec %ecx <== NOT EXECUTED 114396: 81 f9 ff 00 00 00 cmp $0xff,%ecx <== NOT EXECUTED 11439c: 76 0a jbe 1143a8 <_POSIX_Message_queue_Name_to_id+0x40> <== NOT EXECUTED 11439e: b8 5b 00 00 00 mov $0x5b,%eax <== NOT EXECUTED if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) return 0; return ENOENT; } 1143a3: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 1143a6: c9 leave <== NOT EXECUTED 1143a7: c3 ret <== NOT EXECUTED return EINVAL; if( strlen(name) > PATH_MAX ) return ENAMETOOLONG; status = _Objects_Name_to_id_string( 1143a8: 50 push %eax <== NOT EXECUTED 1143a9: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1143ac: 52 push %edx <== NOT EXECUTED 1143ad: 68 20 80 12 00 push $0x128020 <== NOT EXECUTED 1143b2: e8 35 0e 00 00 call 1151ec <_Objects_Name_to_id_string> <== NOT EXECUTED &_POSIX_Message_queue_Information, name, id ); if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) 1143b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1143ba: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 1143bd: 19 c0 sbb %eax,%eax <== NOT EXECUTED 1143bf: f7 d0 not %eax <== NOT EXECUTED 1143c1: 83 e0 02 and $0x2,%eax <== NOT EXECUTED return 0; return ENOENT; } 1143c4: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 1143c7: c9 leave <== NOT EXECUTED 1143c8: c3 ret <== NOT EXECUTED 0010da40 <_POSIX_Message_queue_Notify_handler>: */ void _POSIX_Message_queue_Notify_handler( void *user_data ) { 10da40: 55 push %ebp <== NOT EXECUTED 10da41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10da43: 56 push %esi <== NOT EXECUTED 10da44: 53 push %ebx <== NOT EXECUTED 10da45: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED POSIX_Message_queue_Control *the_mq; the_mq = user_data; kill( getpid(), the_mq->notification.sigev_signo ); 10da48: 8b b3 94 00 00 00 mov 0x94(%ebx),%esi <== NOT EXECUTED 10da4e: e8 89 60 00 00 call 113adc <== NOT EXECUTED 10da53: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10da56: 56 push %esi <== NOT EXECUTED 10da57: 50 push %eax <== NOT EXECUTED 10da58: e8 43 67 00 00 call 1141a0 <== NOT EXECUTED 10da5d: c7 43 7c 00 00 00 00 movl $0x0,0x7c(%ebx) <== NOT EXECUTED 10da64: c7 83 80 00 00 00 00 movl $0x0,0x80(%ebx) <== NOT EXECUTED 10da6b: 00 00 00 <== NOT EXECUTED 10da6e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL ); } 10da71: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10da74: 5b pop %ebx <== NOT EXECUTED 10da75: 5e pop %esi <== NOT EXECUTED 10da76: c9 leave <== NOT EXECUTED 10da77: c3 ret <== NOT EXECUTED 0010dc4c <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) { 10dc4c: 55 push %ebp <== NOT EXECUTED 10dc4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc4f: 57 push %edi <== NOT EXECUTED 10dc50: 56 push %esi <== NOT EXECUTED 10dc51: 53 push %ebx <== NOT EXECUTED 10dc52: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 10dc55: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10dc58: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 10dc5b: 8a 5d 18 mov 0x18(%ebp),%bl <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ); 10dc5e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10dc61: 50 push %eax <== NOT EXECUTED 10dc62: 57 push %edi <== NOT EXECUTED 10dc63: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10dc68: e8 83 31 00 00 call 110df0 <_Objects_Get> <== NOT EXECUTED 10dc6d: 89 c2 mov %eax,%edx <== NOT EXECUTED Objects_Locations location; size_t length_out; bool do_wait; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 10dc6f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dc72: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10dc75: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10dc77: 74 1b je 10dc94 <_POSIX_Message_queue_Receive_support+0x48> <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10dc79: e8 ce 88 00 00 call 11654c <__errno> <== NOT EXECUTED 10dc7e: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10dc84: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 10dc89: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dc8c: 5b pop %ebx <== NOT EXECUTED 10dc8d: 5e pop %esi <== NOT EXECUTED 10dc8e: 5f pop %edi <== NOT EXECUTED 10dc8f: c9 leave <== NOT EXECUTED 10dc90: c3 ret <== NOT EXECUTED 10dc91: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 10dc94: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED 10dc97: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10dc99: 83 e0 03 and $0x3,%eax <== NOT EXECUTED 10dc9c: 48 dec %eax <== NOT EXECUTED 10dc9d: 0f 84 af 00 00 00 je 10dd52 <_POSIX_Message_queue_Receive_support+0x106> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10dca3: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 10dca6: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10dca9: 39 42 68 cmp %eax,0x68(%edx) <== NOT EXECUTED 10dcac: 77 62 ja 10dd10 <_POSIX_Message_queue_Receive_support+0xc4> <== NOT EXECUTED length_out = -1; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10dcae: 84 db test %bl,%bl <== NOT EXECUTED 10dcb0: 75 4a jne 10dcfc <_POSIX_Message_queue_Receive_support+0xb0> <== NOT EXECUTED 10dcb2: 31 c0 xor %eax,%eax <== NOT EXECUTED /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 10dcb4: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp) <== NOT EXECUTED do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 10dcbb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dcbe: ff 75 1c pushl 0x1c(%ebp) <== NOT EXECUTED 10dcc1: 50 push %eax <== NOT EXECUTED 10dcc2: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10dcc5: 50 push %eax <== NOT EXECUTED 10dcc6: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dcc9: 57 push %edi <== NOT EXECUTED 10dcca: 8d 42 1c lea 0x1c(%edx),%eax <== NOT EXECUTED 10dccd: 50 push %eax <== NOT EXECUTED 10dcce: e8 bd 22 00 00 call 10ff90 <_CORE_message_queue_Seize> <== NOT EXECUTED &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 10dcd3: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10dcd6: e8 ad 39 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED *msg_prio = 10dcdb: 8b 15 1c 7d 12 00 mov 0x127d1c,%edx <== NOT EXECUTED 10dce1: 8b 42 24 mov 0x24(%edx),%eax <== NOT EXECUTED 10dce4: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10dce6: 85 c0 test %eax,%eax <== NOT EXECUTED 10dce8: 78 22 js 10dd0c <_POSIX_Message_queue_Receive_support+0xc0> <== NOT EXECUTED _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) 10dcea: 8b 42 34 mov 0x34(%edx),%eax <== NOT EXECUTED 10dced: 85 c0 test %eax,%eax <== NOT EXECUTED 10dcef: 75 3b jne 10dd2c <_POSIX_Message_queue_Receive_support+0xe0> <== NOT EXECUTED return length_out; 10dcf1: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); } 10dcf4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dcf7: 5b pop %ebx <== NOT EXECUTED 10dcf8: 5e pop %esi <== NOT EXECUTED 10dcf9: 5f pop %edi <== NOT EXECUTED 10dcfa: c9 leave <== NOT EXECUTED 10dcfb: c3 ret <== NOT EXECUTED length_out = -1; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10dcfc: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10dcfe: c1 e8 0e shr $0xe,%eax <== NOT EXECUTED 10dd01: 83 f0 01 xor $0x1,%eax <== NOT EXECUTED 10dd04: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10dd07: eb ab jmp 10dcb4 <_POSIX_Message_queue_Receive_support+0x68> <== NOT EXECUTED 10dd09: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED do_wait, timeout ); _Thread_Enable_dispatch(); *msg_prio = 10dd0c: f7 1e negl (%esi) <== NOT EXECUTED 10dd0e: eb da jmp 10dcea <_POSIX_Message_queue_Receive_support+0x9e> <== NOT EXECUTED } the_mq = the_mq_fd->Queue; if ( msg_len < the_mq->Message_queue.maximum_message_size ) { _Thread_Enable_dispatch(); 10dd10: e8 73 39 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EMSGSIZE ); 10dd15: e8 32 88 00 00 call 11654c <__errno> <== NOT EXECUTED 10dd1a: c7 00 7a 00 00 00 movl $0x7a,(%eax) <== NOT EXECUTED 10dd20: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10dd25: e9 5f ff ff ff jmp 10dc89 <_POSIX_Message_queue_Receive_support+0x3d> <== NOT EXECUTED 10dd2a: 66 90 xchg %ax,%ax <== NOT EXECUTED _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) return length_out; rtems_set_errno_and_return_minus_one( 10dd2c: e8 1b 88 00 00 call 11654c <__errno> <== NOT EXECUTED 10dd31: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10dd33: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10dd36: a1 1c 7d 12 00 mov 0x127d1c,%eax <== NOT EXECUTED 10dd3b: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10dd3e: e8 31 02 00 00 call 10df74 <_POSIX_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 10dd43: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10dd45: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10dd4a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dd4d: e9 37 ff ff ff jmp 10dc89 <_POSIX_Message_queue_Receive_support+0x3d> <== NOT EXECUTED the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { _Thread_Enable_dispatch(); 10dd52: e8 31 39 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); 10dd57: e8 f0 87 00 00 call 11654c <__errno> <== NOT EXECUTED 10dd5c: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10dd62: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10dd67: e9 1d ff ff ff jmp 10dc89 <_POSIX_Message_queue_Receive_support+0x3d> <== NOT EXECUTED 0010dd8c <_POSIX_Message_queue_Send_support>: size_t msg_len, uint32_t msg_prio, bool wait, Watchdog_Interval timeout ) { 10dd8c: 55 push %ebp <== NOT EXECUTED 10dd8d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dd8f: 56 push %esi <== NOT EXECUTED 10dd90: 53 push %ebx <== NOT EXECUTED 10dd91: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 10dd94: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10dd97: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 10dd9a: 8a 45 18 mov 0x18(%ebp),%al <== NOT EXECUTED 10dd9d: 88 45 e7 mov %al,-0x19(%ebp) <== NOT EXECUTED /* * Validate the priority. * XXX - Do not validate msg_prio is not less than 0. */ if ( msg_prio > MQ_PRIO_MAX ) 10dda0: 83 fb 20 cmp $0x20,%ebx <== NOT EXECUTED 10dda3: 0f 87 93 00 00 00 ja 10de3c <_POSIX_Message_queue_Send_support+0xb0> <== NOT EXECUTED 10dda9: 51 push %ecx <== NOT EXECUTED 10ddaa: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10ddad: 50 push %eax <== NOT EXECUTED 10ddae: 56 push %esi <== NOT EXECUTED 10ddaf: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10ddb4: e8 37 30 00 00 call 110df0 <_Objects_Get> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 10ddb9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ddbc: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 10ddbf: 85 d2 test %edx,%edx <== NOT EXECUTED 10ddc1: 75 65 jne 10de28 <_POSIX_Message_queue_Send_support+0x9c> <== NOT EXECUTED case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) { 10ddc3: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED 10ddc6: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 10ddc9: 0f 84 81 00 00 00 je 10de50 <_POSIX_Message_queue_Send_support+0xc4> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10ddcf: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10ddd2: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) <== NOT EXECUTED 10ddd6: 75 38 jne 10de10 <_POSIX_Message_queue_Send_support+0x84> <== NOT EXECUTED 10ddd8: 31 d2 xor %edx,%edx <== NOT EXECUTED do_wait = wait; /* * Now perform the actual message receive */ msg_status = _CORE_message_queue_Submit( 10ddda: ff 75 1c pushl 0x1c(%ebp) <== NOT EXECUTED 10dddd: 52 push %edx <== NOT EXECUTED 10ddde: f7 db neg %ebx <== NOT EXECUTED 10dde0: 53 push %ebx <== NOT EXECUTED 10dde1: 6a 00 push $0x0 <== NOT EXECUTED 10dde3: 56 push %esi <== NOT EXECUTED 10dde4: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dde7: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10ddea: 83 c0 1c add $0x1c,%eax <== NOT EXECUTED 10dded: 50 push %eax <== NOT EXECUTED 10ddee: e8 c9 22 00 00 call 1100bc <_CORE_message_queue_Submit> <== NOT EXECUTED 10ddf3: 89 c6 mov %eax,%esi <== NOT EXECUTED _POSIX_Message_queue_Priority_to_core( msg_prio ), do_wait, timeout /* no timeout */ ); _Thread_Enable_dispatch(); 10ddf5: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10ddf8: e8 8b 38 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED * after it wakes up. The returned status is correct for * non-blocking operations but if we blocked, then we need * to look at the status in our TCB. */ if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT ) 10ddfd: 83 fe 07 cmp $0x7,%esi <== NOT EXECUTED 10de00: 74 1a je 10de1c <_POSIX_Message_queue_Send_support+0x90> <== NOT EXECUTED msg_status = _Thread_Executing->Wait.return_code; if ( !msg_status ) 10de02: 85 f6 test %esi,%esi <== NOT EXECUTED 10de04: 75 62 jne 10de68 <_POSIX_Message_queue_Send_support+0xdc> <== NOT EXECUTED 10de06: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); } 10de08: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10de0b: 5b pop %ebx <== NOT EXECUTED 10de0c: 5e pop %esi <== NOT EXECUTED 10de0d: c9 leave <== NOT EXECUTED 10de0e: c3 ret <== NOT EXECUTED 10de0f: 90 nop <== NOT EXECUTED the_mq = the_mq_fd->Queue; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10de10: c1 ea 0e shr $0xe,%edx <== NOT EXECUTED 10de13: 83 f2 01 xor $0x1,%edx <== NOT EXECUTED 10de16: 83 e2 01 and $0x1,%edx <== NOT EXECUTED 10de19: eb bf jmp 10ddda <_POSIX_Message_queue_Send_support+0x4e> <== NOT EXECUTED 10de1b: 90 nop <== NOT EXECUTED * non-blocking operations but if we blocked, then we need * to look at the status in our TCB. */ if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT ) msg_status = _Thread_Executing->Wait.return_code; 10de1c: a1 1c 7d 12 00 mov 0x127d1c,%eax <== NOT EXECUTED 10de21: 8b 70 34 mov 0x34(%eax),%esi <== NOT EXECUTED 10de24: eb dc jmp 10de02 <_POSIX_Message_queue_Send_support+0x76> <== NOT EXECUTED 10de26: 66 90 xchg %ax,%ax <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10de28: e8 1f 87 00 00 call 11654c <__errno> <== NOT EXECUTED 10de2d: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10de33: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10de38: eb ce jmp 10de08 <_POSIX_Message_queue_Send_support+0x7c> <== NOT EXECUTED 10de3a: 66 90 xchg %ax,%ax <== NOT EXECUTED * Validate the priority. * XXX - Do not validate msg_prio is not less than 0. */ if ( msg_prio > MQ_PRIO_MAX ) rtems_set_errno_and_return_minus_one( EINVAL ); 10de3c: e8 0b 87 00 00 call 11654c <__errno> <== NOT EXECUTED 10de41: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10de47: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10de4c: eb ba jmp 10de08 <_POSIX_Message_queue_Send_support+0x7c> <== NOT EXECUTED 10de4e: 66 90 xchg %ax,%ax <== NOT EXECUTED the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) { _Thread_Enable_dispatch(); 10de50: e8 33 38 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); 10de55: e8 f2 86 00 00 call 11654c <__errno> <== NOT EXECUTED 10de5a: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10de60: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10de65: eb a1 jmp 10de08 <_POSIX_Message_queue_Send_support+0x7c> <== NOT EXECUTED 10de67: 90 nop <== NOT EXECUTED msg_status = _Thread_Executing->Wait.return_code; if ( !msg_status ) return msg_status; rtems_set_errno_and_return_minus_one( 10de68: e8 df 86 00 00 call 11654c <__errno> <== NOT EXECUTED 10de6d: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10de6f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10de72: 56 push %esi <== NOT EXECUTED 10de73: e8 fc 00 00 00 call 10df74 <_POSIX_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 10de78: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10de7a: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10de7f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10de82: eb 84 jmp 10de08 <_POSIX_Message_queue_Send_support+0x7c> <== NOT EXECUTED 0010df74 <_POSIX_Message_queue_Translate_core_message_queue_return_code>: int _POSIX_Message_queue_Translate_core_message_queue_return_code( uint32_t the_message_queue_status ) { 10df74: 55 push %ebp <== NOT EXECUTED 10df75: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10df77: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10df7a: 8b 04 85 40 12 12 00 mov 0x121240(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_message_queue_status > CORE_MESSAGE_QUEUE_STATUS_LAST ) return EINVAL; #endif return _POSIX_Message_queue_Return_codes[the_message_queue_status]; } 10df81: c9 leave <== NOT EXECUTED 10df82: c3 ret <== NOT EXECUTED 0010bd50 <_POSIX_Mutex_Get>: POSIX_Mutex_Control *_POSIX_Mutex_Get ( pthread_mutex_t *mutex, Objects_Locations *location ) { 10bd50: 55 push %ebp <== NOT EXECUTED 10bd51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd53: 53 push %ebx <== NOT EXECUTED 10bd54: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bd57: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 10bd5a: 85 db test %ebx,%ebx <== NOT EXECUTED 10bd5c: 74 36 je 10bd94 <_POSIX_Mutex_Get+0x44> <== NOT EXECUTED 10bd5e: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10bd60: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10bd63: 74 17 je 10bd7c <_POSIX_Mutex_Get+0x2c> <== NOT EXECUTED return (POSIX_Mutex_Control *) 10bd65: 52 push %edx <== NOT EXECUTED 10bd66: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10bd69: 50 push %eax <== NOT EXECUTED 10bd6a: 68 a0 55 12 00 push $0x1255a0 <== NOT EXECUTED 10bd6f: e8 9c 2d 00 00 call 10eb10 <_Objects_Get> <== NOT EXECUTED 10bd74: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Objects_Get( &_POSIX_Mutex_Information, *id, location ); } 10bd77: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bd7a: c9 leave <== NOT EXECUTED 10bd7b: c3 ret <== NOT EXECUTED Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 10bd7c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bd7f: 6a 00 push $0x0 <== NOT EXECUTED 10bd81: 53 push %ebx <== NOT EXECUTED 10bd82: e8 69 00 00 00 call 10bdf0 <== NOT EXECUTED 10bd87: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bd8a: 85 c0 test %eax,%eax <== NOT EXECUTED 10bd8c: 75 06 jne 10bd94 <_POSIX_Mutex_Get+0x44> <== NOT EXECUTED 10bd8e: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10bd90: eb d3 jmp 10bd65 <_POSIX_Mutex_Get+0x15> <== NOT EXECUTED 10bd92: 66 90 xchg %ax,%ax <== NOT EXECUTED 10bd94: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10bd97: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10bd9d: 31 c0 xor %eax,%eax 10bd9f: eb d6 jmp 10bd77 <_POSIX_Mutex_Get+0x27> <== NOT EXECUTED 0010bcf8 <_POSIX_Mutex_Get_interrupt_disable>: POSIX_Mutex_Control *_POSIX_Mutex_Get_interrupt_disable ( pthread_mutex_t *mutex, Objects_Locations *location, ISR_Level *level ) { 10bcf8: 55 push %ebp <== NOT EXECUTED 10bcf9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bcfb: 53 push %ebx <== NOT EXECUTED 10bcfc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bcff: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 10bd02: 85 db test %ebx,%ebx <== NOT EXECUTED 10bd04: 74 3a je 10bd40 <_POSIX_Mutex_Get_interrupt_disable+0x48> <== NOT EXECUTED 10bd06: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10bd08: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10bd0b: 74 1b je 10bd28 <_POSIX_Mutex_Get_interrupt_disable+0x30> <== NOT EXECUTED return (POSIX_Mutex_Control *) 10bd0d: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10bd10: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10bd13: 50 push %eax <== NOT EXECUTED 10bd14: 68 a0 55 12 00 push $0x1255a0 <== NOT EXECUTED 10bd19: e8 a6 2d 00 00 call 10eac4 <_Objects_Get_isr_disable> <== NOT EXECUTED 10bd1e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Objects_Get_isr_disable( &_POSIX_Mutex_Information, *id, location, level ); } 10bd21: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bd24: c9 leave <== NOT EXECUTED 10bd25: c3 ret <== NOT EXECUTED 10bd26: 66 90 xchg %ax,%ax <== NOT EXECUTED ISR_Level *level ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 10bd28: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bd2b: 6a 00 push $0x0 <== NOT EXECUTED 10bd2d: 53 push %ebx <== NOT EXECUTED 10bd2e: e8 bd 00 00 00 call 10bdf0 <== NOT EXECUTED 10bd33: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bd36: 85 c0 test %eax,%eax <== NOT EXECUTED 10bd38: 75 06 jne 10bd40 <_POSIX_Mutex_Get_interrupt_disable+0x48> <== NOT EXECUTED 10bd3a: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10bd3c: eb cf jmp 10bd0d <_POSIX_Mutex_Get_interrupt_disable+0x15> <== NOT EXECUTED 10bd3e: 66 90 xchg %ax,%ax <== NOT EXECUTED 10bd40: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10bd43: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10bd49: 31 c0 xor %eax,%eax 10bd4b: eb d4 jmp 10bd21 <_POSIX_Mutex_Get_interrupt_disable+0x29> <== NOT EXECUTED 0010bf40 <_POSIX_Mutex_Lock_support>: int _POSIX_Mutex_Lock_support( pthread_mutex_t *mutex, bool blocking, Watchdog_Interval timeout ) { 10bf40: 55 push %ebp <== NOT EXECUTED 10bf41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bf43: 53 push %ebx <== NOT EXECUTED 10bf44: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10bf47: 8a 5d 0c mov 0xc(%ebp),%bl <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; ISR_Level level; the_mutex = _POSIX_Mutex_Get_interrupt_disable( mutex, &location, &level ); 10bf4a: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10bf4d: 50 push %eax <== NOT EXECUTED 10bf4e: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10bf51: 50 push %eax <== NOT EXECUTED 10bf52: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bf55: e8 9e fd ff ff call 10bcf8 <_POSIX_Mutex_Get_interrupt_disable> <== NOT EXECUTED 10bf5a: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 10bf5c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bf5f: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10bf62: 85 c0 test %eax,%eax <== NOT EXECUTED 10bf64: 75 32 jne 10bf98 <_POSIX_Mutex_Lock_support+0x58> <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_mutex_Seize( 10bf66: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bf69: ff 75 f4 pushl -0xc(%ebp) <== NOT EXECUTED 10bf6c: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10bf6f: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10bf72: 50 push %eax <== NOT EXECUTED 10bf73: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED 10bf76: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 10bf79: 50 push %eax <== NOT EXECUTED 10bf7a: e8 79 20 00 00 call 10dff8 <_CORE_mutex_Seize> <== NOT EXECUTED the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_Translate_core_mutex_return_code( 10bf7f: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10bf82: a1 5c 52 12 00 mov 0x12525c,%eax <== NOT EXECUTED 10bf87: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10bf8a: e8 e1 00 00 00 call 10c070 <_POSIX_Mutex_Translate_core_mutex_return_code> <== NOT EXECUTED 10bf8f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10bf92: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bf95: c9 leave <== NOT EXECUTED 10bf96: c3 ret <== NOT EXECUTED 10bf97: 90 nop <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; ISR_Level level; the_mutex = _POSIX_Mutex_Get_interrupt_disable( mutex, &location, &level ); switch ( location ) { 10bf98: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10bf9d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bfa0: c9 leave <== NOT EXECUTED 10bfa1: c3 ret <== NOT EXECUTED 0010ed0c <_POSIX_Mutex_Manager_initialization>: */ void _POSIX_Mutex_Manager_initialization( uint32_t maximum_mutexes ) { 10ed0c: 55 push %ebp <== NOT EXECUTED 10ed0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ed0f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ed12: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10ed17: 6a 01 push $0x1 <== NOT EXECUTED 10ed19: 6a 78 push $0x78 <== NOT EXECUTED 10ed1b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ed1e: 6a 06 push $0x6 <== NOT EXECUTED 10ed20: 6a 03 push $0x3 <== NOT EXECUTED 10ed22: 68 c0 fb 11 00 push $0x11fbc0 <== NOT EXECUTED 10ed27: e8 40 ce ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10ed2c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ed2f: c9 leave <== NOT EXECUTED 10ed30: c3 ret <== NOT EXECUTED 0010c070 <_POSIX_Mutex_Translate_core_mutex_return_code>: int _POSIX_Mutex_Translate_core_mutex_return_code( CORE_mutex_Status the_mutex_status ) { 10c070: 55 push %ebp <== NOT EXECUTED 10c071: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c073: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c076: 8b 04 85 8c e7 11 00 mov 0x11e78c(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_mutex_status > CORE_MUTEX_STATUS_LAST ) return EINVAL; #endif return _POSIX_Mutex_Return_codes[the_mutex_status]; } 10c07d: c9 leave <== NOT EXECUTED 10c07e: c3 ret <== NOT EXECUTED 0010ed5c <_POSIX_RWLock_Manager_initialization>: */ void _POSIX_RWLock_Manager_initialization( uint32_t maximum_rwlocks ) { 10ed5c: 55 push %ebp <== NOT EXECUTED 10ed5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ed5f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ed62: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10ed67: 6a 01 push $0x1 <== NOT EXECUTED 10ed69: 6a 5c push $0x5c <== NOT EXECUTED 10ed6b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ed6e: 6a 0b push $0xb <== NOT EXECUTED 10ed70: 6a 03 push $0x3 <== NOT EXECUTED 10ed72: 68 40 fa 11 00 push $0x11fa40 <== NOT EXECUTED 10ed77: e8 f0 cd ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10ed7c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ed7f: c9 leave <== NOT EXECUTED 10ed80: c3 ret <== NOT EXECUTED 0010ae00 <_POSIX_RWLock_Translate_core_RWLock_return_code>: int _POSIX_RWLock_Translate_core_RWLock_return_code( CORE_RWLock_Status the_rwlock_status ) { 10ae00: 55 push %ebp <== NOT EXECUTED 10ae01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae03: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ae06: 8b 04 85 48 b8 11 00 mov 0x11b848(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_rwlock_status > CORE_RWLOCK_STATUS_LAST ) return EINVAL; #endif return _POSIX_RWLock_Return_codes[the_rwlock_status]; } 10ae0d: c9 leave <== NOT EXECUTED 10ae0e: c3 ret <== NOT EXECUTED 001126a4 <_POSIX_Semaphore_Create_support>: const char *name, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) { 1126a4: 55 push %ebp <== NOT EXECUTED 1126a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1126a7: 57 push %edi <== NOT EXECUTED 1126a8: 56 push %esi <== NOT EXECUTED 1126a9: 53 push %ebx <== NOT EXECUTED 1126aa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1126ad: 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 1126b0: a1 d8 58 12 00 mov 0x1258d8,%eax <== NOT EXECUTED 1126b5: 40 inc %eax <== NOT EXECUTED 1126b6: a3 d8 58 12 00 mov %eax,0x1258d8 <== NOT EXECUTED char *name_p = (char *)name; _Thread_Disable_dispatch(); /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) { 1126bb: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 1126be: 85 d2 test %edx,%edx <== NOT EXECUTED 1126c0: 0f 85 ae 00 00 00 jne 112774 <_POSIX_Semaphore_Create_support+0xd0> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOSYS ); } if ( name ) { 1126c6: 85 f6 test %esi,%esi <== NOT EXECUTED 1126c8: 74 1a je 1126e4 <_POSIX_Semaphore_Create_support+0x40> <== NOT EXECUTED if( strlen(name) > PATH_MAX ) { 1126ca: 31 c0 xor %eax,%eax <== NOT EXECUTED 1126cc: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 1126d1: 89 f7 mov %esi,%edi <== NOT EXECUTED 1126d3: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 1126d5: f7 d1 not %ecx <== NOT EXECUTED 1126d7: 49 dec %ecx <== NOT EXECUTED 1126d8: 81 f9 ff 00 00 00 cmp $0xff,%ecx <== NOT EXECUTED 1126de: 0f 87 a8 00 00 00 ja 11278c <_POSIX_Semaphore_Create_support+0xe8> <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 1126e4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1126e7: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 1126ec: e8 3b bf ff ff call 10e62c <_Objects_Allocate> <== NOT EXECUTED 1126f1: 89 c3 mov %eax,%ebx <== NOT EXECUTED } } the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { 1126f3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1126f6: 85 c0 test %eax,%eax <== NOT EXECUTED 1126f8: 0f 84 a5 00 00 00 je 1127a3 <_POSIX_Semaphore_Create_support+0xff> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOSPC ); } the_semaphore->process_shared = pshared; 1126fe: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) <== NOT EXECUTED if ( name ) { 112705: 85 f6 test %esi,%esi <== NOT EXECUTED 112707: 74 57 je 112760 <_POSIX_Semaphore_Create_support+0xbc> <== NOT EXECUTED the_semaphore->named = TRUE; 112709: c6 40 14 01 movb $0x1,0x14(%eax) <== NOT EXECUTED the_semaphore->open_count = 1; 11270d: c7 40 18 01 00 00 00 movl $0x1,0x18(%eax) <== NOT EXECUTED the_semaphore->linked = TRUE; 112714: c6 40 15 01 movb $0x1,0x15(%eax) <== NOT EXECUTED * be derived from the current scheduling policy. One * thing is certain, no matter what we decide, it won't be * the same as all other POSIX implementations. :) */ the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO; 112718: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 11271f: c7 43 5c ff ff ff ff movl $0xffffffff,0x5c(%ebx) <== NOT EXECUTED _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 112726: 50 push %eax <== NOT EXECUTED 112727: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 11272a: 8d 43 5c lea 0x5c(%ebx),%eax <== NOT EXECUTED 11272d: 50 push %eax <== NOT EXECUTED 11272e: 8d 43 1c lea 0x1c(%ebx),%eax <== NOT EXECUTED 112731: 50 push %eax <== NOT EXECUTED 112732: e8 fd ba ff ff call 10e234 <_CORE_semaphore_Initialize> <== NOT EXECUTED 112737: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 11273b: a1 3c 5c 12 00 mov 0x125c3c,%eax <== NOT EXECUTED 112740: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 112743: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_POSIX_Semaphore_Information, &the_semaphore->Object, name_p ); *the_sem = the_semaphore; 112746: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 112749: 89 18 mov %ebx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 11274b: e8 14 cc ff ff call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED 112750: 31 c0 xor %eax,%eax <== NOT EXECUTED 112752: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 112755: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112758: 5b pop %ebx <== NOT EXECUTED 112759: 5e pop %esi <== NOT EXECUTED 11275a: 5f pop %edi <== NOT EXECUTED 11275b: c9 leave <== NOT EXECUTED 11275c: c3 ret <== NOT EXECUTED 11275d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( name ) { the_semaphore->named = TRUE; the_semaphore->open_count = 1; the_semaphore->linked = TRUE; } else { the_semaphore->named = FALSE; 112760: c6 40 14 00 movb $0x0,0x14(%eax) <== NOT EXECUTED the_semaphore->open_count = 0; 112764: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED the_semaphore->linked = FALSE; 11276b: c6 40 15 00 movb $0x0,0x15(%eax) <== NOT EXECUTED 11276f: eb a7 jmp 112718 <_POSIX_Semaphore_Create_support+0x74> <== NOT EXECUTED 112771: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Disable_dispatch(); /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) { _Thread_Enable_dispatch(); 112774: e8 eb cb ff ff call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 112779: e8 0a 1d 00 00 call 114488 <__errno> <== NOT EXECUTED 11277e: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED 112784: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 112789: eb ca jmp 112755 <_POSIX_Semaphore_Create_support+0xb1> <== NOT EXECUTED 11278b: 90 nop <== NOT EXECUTED } if ( name ) { if( strlen(name) > PATH_MAX ) { _Thread_Enable_dispatch(); 11278c: e8 d3 cb ff ff call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 112791: e8 f2 1c 00 00 call 114488 <__errno> <== NOT EXECUTED 112796: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED 11279c: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1127a1: eb b2 jmp 112755 <_POSIX_Semaphore_Create_support+0xb1> <== NOT EXECUTED } the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { _Thread_Enable_dispatch(); 1127a3: e8 bc cb ff ff call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); 1127a8: e8 db 1c 00 00 call 114488 <__errno> <== NOT EXECUTED 1127ad: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 1127b3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1127b8: eb 9b jmp 112755 <_POSIX_Semaphore_Create_support+0xb1> <== NOT EXECUTED 001127bc <_POSIX_Semaphore_Delete>: */ void _POSIX_Semaphore_Delete( POSIX_Semaphore_Control *the_semaphore ) { 1127bc: 55 push %ebp <== NOT EXECUTED 1127bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1127bf: 53 push %ebx <== NOT EXECUTED 1127c0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1127c3: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( !the_semaphore->linked && !the_semaphore->open_count ) { 1127c6: 80 7b 15 00 cmpb $0x0,0x15(%ebx) <== NOT EXECUTED 1127ca: 75 07 jne 1127d3 <_POSIX_Semaphore_Delete+0x17> <== NOT EXECUTED 1127cc: 8b 4b 18 mov 0x18(%ebx),%ecx <== NOT EXECUTED 1127cf: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1127d1: 74 05 je 1127d8 <_POSIX_Semaphore_Delete+0x1c> <== NOT EXECUTED -1 ); _POSIX_Semaphore_Free( the_semaphore ); } } 1127d3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1127d6: c9 leave <== NOT EXECUTED 1127d7: c3 ret <== NOT EXECUTED void _POSIX_Semaphore_Delete( POSIX_Semaphore_Control *the_semaphore ) { if ( !the_semaphore->linked && !the_semaphore->open_count ) { _Objects_Close( &_POSIX_Semaphore_Information, &the_semaphore->Object ); 1127d8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1127db: 53 push %ebx <== NOT EXECUTED 1127dc: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 1127e1: e8 c6 be ff ff call 10e6ac <_Objects_Close> <== NOT EXECUTED _CORE_semaphore_Flush( 1127e6: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1127e9: 6a ff push $0xffffffff <== NOT EXECUTED 1127eb: 6a 00 push $0x0 <== NOT EXECUTED 1127ed: 8d 43 1c lea 0x1c(%ebx),%eax <== NOT EXECUTED 1127f0: 50 push %eax <== NOT EXECUTED 1127f1: e8 32 ba ff ff call 10e228 <_CORE_semaphore_Flush> <== 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 1127f6: 58 pop %eax <== NOT EXECUTED 1127f7: 5a pop %edx <== NOT EXECUTED 1127f8: 53 push %ebx <== NOT EXECUTED 1127f9: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 1127fe: e8 e9 c1 ff ff call 10e9ec <_Objects_Free> <== NOT EXECUTED 112803: 83 c4 10 add $0x10,%esp <== NOT EXECUTED -1 ); _POSIX_Semaphore_Free( the_semaphore ); } } 112806: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112809: c9 leave <== NOT EXECUTED 11280a: c3 ret <== NOT EXECUTED 0010f23c <_POSIX_Semaphore_Manager_initialization>: */ void _POSIX_Semaphore_Manager_initialization( uint32_t maximum_semaphores ) { 10f23c: 55 push %ebp <== NOT EXECUTED 10f23d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f23f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f242: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10f247: 6a 01 push $0x1 <== NOT EXECUTED 10f249: 6a 68 push $0x68 <== NOT EXECUTED 10f24b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f24e: 6a 07 push $0x7 <== NOT EXECUTED 10f250: 6a 03 push $0x3 <== NOT EXECUTED 10f252: 68 00 fb 11 00 push $0x11fb00 <== NOT EXECUTED 10f257: e8 10 c9 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10f25c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10f25f: c9 leave <== NOT EXECUTED 10f260: c3 ret <== NOT EXECUTED 0011280c <_POSIX_Semaphore_Name_to_id>: int _POSIX_Semaphore_Name_to_id( const char *name, sem_t *id ) { 11280c: 55 push %ebp <== NOT EXECUTED 11280d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11280f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 112812: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; if ( !name ) 112815: 85 c0 test %eax,%eax <== NOT EXECUTED 112817: 74 05 je 11281e <_POSIX_Semaphore_Name_to_id+0x12> <== NOT EXECUTED return EINVAL; if ( !name[0] ) 112819: 80 38 00 cmpb $0x0,(%eax) <== NOT EXECUTED 11281c: 75 0a jne 112828 <_POSIX_Semaphore_Name_to_id+0x1c> <== NOT EXECUTED return EINVAL; status = _Objects_Name_to_id_string( &_POSIX_Semaphore_Information, name, (Objects_Id*)id ); if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) 11281e: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED return 0; return ENOENT; } 112823: c9 leave <== NOT EXECUTED 112824: c3 ret <== NOT EXECUTED 112825: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return EINVAL; if ( !name[0] ) return EINVAL; status = _Objects_Name_to_id_string( 112828: 52 push %edx <== NOT EXECUTED 112829: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11282c: 50 push %eax <== NOT EXECUTED 11282d: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 112832: e8 59 0a 00 00 call 113290 <_Objects_Name_to_id_string> <== NOT EXECUTED &_POSIX_Semaphore_Information, name, (Objects_Id*)id ); if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) 112837: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11283a: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 11283d: 19 c0 sbb %eax,%eax <== NOT EXECUTED 11283f: f7 d0 not %eax <== NOT EXECUTED 112841: 83 e0 02 and $0x2,%eax <== NOT EXECUTED return 0; return ENOENT; } 112844: c9 leave <== NOT EXECUTED 112845: c3 ret <== NOT EXECUTED 00113f84 <_POSIX_Semaphore_Translate_core_semaphore_return_code>: int _POSIX_Semaphore_Translate_core_semaphore_return_code( CORE_semaphore_Status the_semaphore_status ) { 113f84: 55 push %ebp <== NOT EXECUTED 113f85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113f87: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 113f8a: 8b 04 85 54 ef 11 00 mov 0x11ef54(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_semaphore_status > CORE_SEMAPHORE_STATUS_LAST ) return EINVAL; #endif return _POSIX_Semaphore_Return_codes[the_semaphore_status]; } 113f91: c9 leave <== NOT EXECUTED 113f92: c3 ret <== NOT EXECUTED 00112870 <_POSIX_Semaphore_Wait_support>: int _POSIX_Semaphore_Wait_support( sem_t *sem, bool blocking, Watchdog_Interval timeout ) { 112870: 55 push %ebp <== NOT EXECUTED 112871: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112873: 53 push %ebx <== NOT EXECUTED 112874: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 112877: 8a 5d 0c mov 0xc(%ebp),%bl <== NOT EXECUTED * 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( Heap_Control *the_heap, 11287a: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 11287d: 50 push %eax <== NOT EXECUTED 11287e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 112881: ff 30 pushl (%eax) <== NOT EXECUTED 112883: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 112888: e8 93 c2 ff ff call 10eb20 <_Objects_Get> <== NOT EXECUTED 11288d: 89 c2 mov %eax,%edx <== NOT EXECUTED POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 11288f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112892: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 112895: 85 c9 test %ecx,%ecx <== NOT EXECUTED 112897: 74 17 je 1128b0 <_POSIX_Semaphore_Wait_support+0x40> <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 112899: e8 ea 1b 00 00 call 114488 <__errno> <== NOT EXECUTED 11289e: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1128a4: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 1128a9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1128ac: c9 leave <== NOT EXECUTED 1128ad: c3 ret <== NOT EXECUTED 1128ae: 66 90 xchg %ax,%ax <== NOT EXECUTED the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_semaphore_Seize( 1128b0: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1128b3: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 1128b6: 50 push %eax <== NOT EXECUTED 1128b7: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED 1128ba: 8d 42 1c lea 0x1c(%edx),%eax <== NOT EXECUTED 1128bd: 50 push %eax <== NOT EXECUTED 1128be: e8 c5 06 00 00 call 112f88 <_CORE_semaphore_Seize> <== NOT EXECUTED &the_semaphore->Semaphore, the_semaphore->Object.id, blocking, timeout ); _Thread_Enable_dispatch(); 1128c3: e8 9c ca ff ff call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( !_Thread_Executing->Wait.return_code ) 1128c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1128cb: a1 9c 59 12 00 mov 0x12599c,%eax <== NOT EXECUTED 1128d0: 8b 40 34 mov 0x34(%eax),%eax <== NOT EXECUTED 1128d3: 85 c0 test %eax,%eax <== NOT EXECUTED 1128d5: 75 09 jne 1128e0 <_POSIX_Semaphore_Wait_support+0x70> <== NOT EXECUTED 1128d7: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 1128d9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1128dc: c9 leave <== NOT EXECUTED 1128dd: c3 ret <== NOT EXECUTED 1128de: 66 90 xchg %ax,%ax <== NOT EXECUTED _Thread_Enable_dispatch(); if ( !_Thread_Executing->Wait.return_code ) return 0; rtems_set_errno_and_return_minus_one( 1128e0: e8 a3 1b 00 00 call 114488 <__errno> <== NOT EXECUTED 1128e5: 89 c3 mov %eax,%ebx <== NOT EXECUTED 1128e7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1128ea: a1 9c 59 12 00 mov 0x12599c,%eax <== NOT EXECUTED 1128ef: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 1128f2: e8 8d 16 00 00 call 113f84 <_POSIX_Semaphore_Translate_core_semaphore_return_code> <== NOT EXECUTED 1128f7: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 1128f9: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1128fe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112901: eb a6 jmp 1128a9 <_POSIX_Semaphore_Wait_support+0x39> <== NOT EXECUTED 0010eedc <_POSIX_Spinlock_Manager_initialization>: */ void _POSIX_Spinlock_Manager_initialization( uint32_t maximum_spinlocks ) { 10eedc: 55 push %ebp <== NOT EXECUTED 10eedd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10eedf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10eee2: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10eee7: 6a 01 push $0x1 <== NOT EXECUTED 10eee9: 6a 20 push $0x20 <== NOT EXECUTED 10eeeb: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10eeee: 6a 0b push $0xb <== NOT EXECUTED 10eef0: 6a 03 push $0x3 <== NOT EXECUTED 10eef2: 68 c0 fa 11 00 push $0x11fac0 <== NOT EXECUTED 10eef7: e8 70 cc ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10eefc: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10eeff: c9 leave <== NOT EXECUTED 10ef00: c3 ret <== NOT EXECUTED 0010a34c <_POSIX_Spinlock_Translate_core_spinlock_return_code>: int _POSIX_Spinlock_Translate_core_spinlock_return_code( CORE_spinlock_Status the_spinlock_status ) { 10a34c: 55 push %ebp <== NOT EXECUTED 10a34d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a34f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a352: 8b 04 85 e8 a0 11 00 mov 0x11a0e8(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_spinlock_status > CORE_SPINLOCK_STATUS_LAST ) return EINVAL; #endif return _POSIX_Spinlock_Return_codes[the_spinlock_status]; } 10a359: c9 leave <== NOT EXECUTED 10a35a: c3 ret <== NOT EXECUTED 0011070c <_POSIX_Thread_Exit>: void _POSIX_Thread_Exit( Thread_Control *the_thread, void *value_ptr ) { 11070c: 55 push %ebp <== NOT EXECUTED 11070d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11070f: 57 push %edi <== NOT EXECUTED 110710: 56 push %esi <== NOT EXECUTED 110711: 53 push %ebx <== NOT EXECUTED 110712: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 110715: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 110718: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Objects_Information *the_information; the_information = _Objects_Get_information_id( the_thread->Object.id ); 11071b: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 11071e: e8 25 b3 ff ff call 10ba48 <_Objects_Get_information_id> <== NOT EXECUTED 110723: 89 c6 mov %eax,%esi <== NOT EXECUTED * are ready to be switched out. Otherwise, an ISR could * occur and preempt us out while we still hold the * allocator mutex. */ _RTEMS_Lock_allocator(); 110725: 58 pop %eax <== NOT EXECUTED 110726: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 11072c: e8 37 a6 ff ff call 10ad68 <_API_Mutex_Lock> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 110731: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 110736: 40 inc %eax <== NOT EXECUTED 110737: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED _Thread_Disable_dispatch(); the_thread->Wait.return_argument = value_ptr; 11073c: 89 7b 28 mov %edi,0x28(%ebx) <== NOT EXECUTED _Thread_Close( the_information, the_thread ); 11073f: 5f pop %edi <== NOT EXECUTED 110740: 58 pop %eax <== NOT EXECUTED 110741: 53 push %ebx <== NOT EXECUTED 110742: 56 push %esi <== NOT EXECUTED 110743: e8 e8 b8 ff ff call 10c030 <_Thread_Close> <== NOT EXECUTED * 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. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 110748: 5a pop %edx <== NOT EXECUTED 110749: 59 pop %ecx <== NOT EXECUTED 11074a: 53 push %ebx <== NOT EXECUTED 11074b: 68 80 fa 11 00 push $0x11fa80 <== NOT EXECUTED 110750: e8 7f b2 ff ff call 10b9d4 <_Objects_Free> <== NOT EXECUTED _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 110755: 58 pop %eax <== NOT EXECUTED 110756: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 11075c: e8 4f a6 ff ff call 10adb0 <_API_Mutex_Unlock> <== NOT EXECUTED _Thread_Enable_dispatch(); 110761: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 110764: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 110767: 5b pop %ebx <== NOT EXECUTED 110768: 5e pop %esi <== NOT EXECUTED 110769: 5f pop %edi <== NOT EXECUTED 11076a: c9 leave <== NOT EXECUTED _Thread_Close( the_information, the_thread ); _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); _Thread_Enable_dispatch(); 11076b: e9 dc bb ff ff jmp 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED 0010f00c <_POSIX_Threads_Create_extension>: bool _POSIX_Threads_Create_extension( Thread_Control *executing, Thread_Control *created ) { 10f00c: 55 push %ebp <== NOT EXECUTED 10f00d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f00f: 57 push %edi <== NOT EXECUTED 10f010: 56 push %esi <== NOT EXECUTED 10f011: 53 push %ebx <== NOT EXECUTED 10f012: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED POSIX_API_Control *api; POSIX_API_Control *executing_api; api = _Workspace_Allocate( sizeof( POSIX_API_Control ) ); 10f015: 68 e4 00 00 00 push $0xe4 <== NOT EXECUTED 10f01a: e8 61 e4 ff ff call 10d480 <_Workspace_Allocate> <== NOT EXECUTED 10f01f: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !api ) 10f021: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f024: 85 c0 test %eax,%eax <== NOT EXECUTED 10f026: 0f 84 10 01 00 00 je 10f13c <_POSIX_Threads_Create_extension+0x130> <== NOT EXECUTED return false; created->API_Extensions[ THREAD_API_POSIX ] = api; 10f02c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f02f: 89 98 f8 00 00 00 mov %ebx,0xf8(%eax) <== NOT EXECUTED /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; 10f035: be 20 97 11 00 mov $0x119720,%esi <== NOT EXECUTED 10f03a: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 10f03f: 89 df mov %ebx,%edi <== NOT EXECUTED 10f041: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED api->detachstate = _POSIX_Threads_Default_attributes.detachstate; 10f043: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) <== NOT EXECUTED api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; 10f04a: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx) <== NOT EXECUTED api->schedparam = _POSIX_Threads_Default_attributes.schedparam; 10f051: be 38 97 11 00 mov $0x119738,%esi <== NOT EXECUTED 10f056: 8d bb 80 00 00 00 lea 0x80(%ebx),%edi <== NOT EXECUTED 10f05c: b1 06 mov $0x6,%cl <== NOT EXECUTED 10f05e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED api->schedparam.sched_priority = 10f060: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10f065: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10f068: 2b 42 14 sub 0x14(%edx),%eax <== NOT EXECUTED 10f06b: 89 83 80 00 00 00 mov %eax,0x80(%ebx) <== NOT EXECUTED _POSIX_Priority_From_core( created->current_priority ); /* * POSIX 1003.1 1996, 18.2.2.2 */ api->cancelation_requested = 0; 10f071: c7 83 d4 00 00 00 00 movl $0x0,0xd4(%ebx) <== NOT EXECUTED 10f078: 00 00 00 <== NOT EXECUTED api->cancelability_state = PTHREAD_CANCEL_ENABLE; 10f07b: c7 83 cc 00 00 00 00 movl $0x0,0xcc(%ebx) <== NOT EXECUTED 10f082: 00 00 00 <== NOT EXECUTED api->cancelability_type = PTHREAD_CANCEL_DEFERRED; 10f085: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx) <== NOT EXECUTED 10f08c: 00 00 00 <== NOT EXECUTED 10f08f: 8d 83 dc 00 00 00 lea 0xdc(%ebx),%eax <== NOT EXECUTED 10f095: 89 83 d8 00 00 00 mov %eax,0xd8(%ebx) <== NOT EXECUTED 10f09b: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx) <== NOT EXECUTED 10f0a2: 00 00 00 <== NOT EXECUTED 10f0a5: 8d 83 d8 00 00 00 lea 0xd8(%ebx),%eax <== NOT EXECUTED 10f0ab: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx) <== NOT EXECUTED * If the thread is not a posix thread, then all posix signals are blocked * by default. */ /* XXX use signal constants */ api->signals_pending = 0; 10f0b1: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED 10f0b8: 00 00 00 <== NOT EXECUTED if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API && 10f0bb: 8b 52 08 mov 0x8(%edx),%edx <== NOT EXECUTED 10f0be: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f0c0: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10f0c3: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 10f0c6: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10f0c9: 74 51 je 10f11c <_POSIX_Threads_Create_extension+0x110> <== NOT EXECUTED _Objects_Get_class( created->Object.id ) == 1 ) { executing_api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; api->signals_blocked = executing_api->signals_blocked; } else { api->signals_blocked = 0xffffffff; 10f0cb: c7 83 c4 00 00 00 ff movl $0xffffffff,0xc4(%ebx) <== NOT EXECUTED 10f0d2: ff ff ff <== NOT EXECUTED } _Thread_queue_Initialize( 10f0d5: 6a 00 push $0x0 <== NOT EXECUTED 10f0d7: 68 00 10 00 00 push $0x1000 <== NOT EXECUTED 10f0dc: 6a 00 push $0x0 <== NOT EXECUTED 10f0de: 8d 43 3c lea 0x3c(%ebx),%eax <== NOT EXECUTED 10f0e1: 50 push %eax <== NOT EXECUTED 10f0e2: e8 99 d9 ff ff call 10ca80 <_Thread_queue_Initialize> <== NOT EXECUTED THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_JOIN_AT_EXIT, 0 ); _Watchdog_Initialize( 10f0e7: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10f0ea: 8b 42 08 mov 0x8(%edx),%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. * 10f0ed: c7 83 a4 00 00 00 00 movl $0x0,0xa4(%ebx) <== NOT EXECUTED 10f0f4: 00 00 00 <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10f0f7: c7 83 b8 00 00 00 88 movl $0x10f188,0xb8(%ebx) <== NOT EXECUTED 10f0fe: f1 10 00 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10f101: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) <== NOT EXECUTED * the heap 10f107: 89 93 c0 00 00 00 mov %edx,0xc0(%ebx) <== NOT EXECUTED 10f10d: b0 01 mov $0x1,%al <== NOT EXECUTED 10f10f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED created->Object.id, created ); return true; } 10f112: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f115: 5b pop %ebx <== NOT EXECUTED 10f116: 5e pop %esi <== NOT EXECUTED 10f117: 5f pop %edi <== NOT EXECUTED 10f118: c9 leave <== NOT EXECUTED 10f119: c3 ret <== NOT EXECUTED 10f11a: 66 90 xchg %ax,%ax <== NOT EXECUTED * by default. */ /* XXX use signal constants */ api->signals_pending = 0; if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API && 10f11c: c1 ea 1b shr $0x1b,%edx <== NOT EXECUTED 10f11f: 4a dec %edx <== NOT EXECUTED 10f120: 75 a9 jne 10f0cb <_POSIX_Threads_Create_extension+0xbf> <== NOT EXECUTED _Objects_Get_class( created->Object.id ) == 1 ) { executing_api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; api->signals_blocked = executing_api->signals_blocked; 10f122: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED 10f127: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax <== NOT EXECUTED 10f12d: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED 10f133: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx) <== NOT EXECUTED 10f139: eb 9a jmp 10f0d5 <_POSIX_Threads_Create_extension+0xc9> <== NOT EXECUTED 10f13b: 90 nop <== NOT EXECUTED POSIX_API_Control *api; POSIX_API_Control *executing_api; api = _Workspace_Allocate( sizeof( POSIX_API_Control ) ); if ( !api ) 10f13c: 31 c0 xor %eax,%eax <== NOT EXECUTED created->Object.id, created ); return true; } 10f13e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f141: 5b pop %ebx <== NOT EXECUTED 10f142: 5e pop %esi <== NOT EXECUTED 10f143: 5f pop %edi <== NOT EXECUTED 10f144: c9 leave <== NOT EXECUTED 10f145: c3 ret <== NOT EXECUTED 0010ef88 <_POSIX_Threads_Delete_extension>: User_extensions_routine _POSIX_Threads_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 10ef88: 55 push %ebp <== NOT EXECUTED 10ef89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ef8b: 57 push %edi <== NOT EXECUTED 10ef8c: 56 push %esi <== NOT EXECUTED 10ef8d: 53 push %ebx <== NOT EXECUTED 10ef8e: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10ef91: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Thread_Control *the_thread; POSIX_API_Control *api; void **value_ptr; api = deleted->API_Extensions[ THREAD_API_POSIX ]; 10ef94: 8b 87 f8 00 00 00 mov 0xf8(%edi),%eax <== NOT EXECUTED 10ef9a: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED /* * Run the POSIX cancellation handlers */ _POSIX_Threads_cancel_run( deleted ); 10ef9d: 57 push %edi <== NOT EXECUTED 10ef9e: e8 a1 14 00 00 call 110444 <_POSIX_Threads_cancel_run> <== NOT EXECUTED /* * Run all the key destructors */ _POSIX_Keys_Run_destructors( deleted ); 10efa3: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10efa6: e8 fd 14 00 00 call 1104a8 <_POSIX_Keys_Run_destructors> <== NOT EXECUTED /* * Wakeup all the tasks which joined with this one */ value_ptr = (void **) deleted->Wait.return_argument; 10efab: 8b 77 28 mov 0x28(%edi),%esi <== NOT EXECUTED while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) 10efae: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 10efb1: 83 c3 3c add $0x3c,%ebx <== NOT EXECUTED 10efb4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10efb7: eb 08 jmp 10efc1 <_POSIX_Threads_Delete_extension+0x39> <== NOT EXECUTED 10efb9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED *(void **)the_thread->Wait.return_argument = value_ptr; 10efbc: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 10efbf: 89 30 mov %esi,(%eax) <== NOT EXECUTED /* * Wakeup all the tasks which joined with this one */ value_ptr = (void **) deleted->Wait.return_argument; while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) 10efc1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10efc4: 53 push %ebx <== NOT EXECUTED 10efc5: e8 06 d7 ff ff call 10c6d0 <_Thread_queue_Dequeue> <== NOT EXECUTED 10efca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10efcd: 85 c0 test %eax,%eax <== NOT EXECUTED 10efcf: 75 eb jne 10efbc <_POSIX_Threads_Delete_extension+0x34> <== NOT EXECUTED *(void **)the_thread->Wait.return_argument = value_ptr; if ( api->schedpolicy == SCHED_SPORADIC ) 10efd1: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10efd4: 83 78 7c 03 cmpl $0x3,0x7c(%eax) <== NOT EXECUTED 10efd8: 74 1e je 10eff8 <_POSIX_Threads_Delete_extension+0x70> <== NOT EXECUTED (void) _Watchdog_Remove( &api->Sporadic_timer ); deleted->API_Extensions[ THREAD_API_POSIX ] = NULL; 10efda: c7 87 f8 00 00 00 00 movl $0x0,0xf8(%edi) <== NOT EXECUTED 10efe1: 00 00 00 <== NOT EXECUTED (void) _Workspace_Free( api ); 10efe4: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10efe7: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10efea: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10efed: 5b pop %ebx <== NOT EXECUTED 10efee: 5e pop %esi <== NOT EXECUTED 10efef: 5f pop %edi <== NOT EXECUTED 10eff0: c9 leave <== NOT EXECUTED if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); deleted->API_Extensions[ THREAD_API_POSIX ] = NULL; (void) _Workspace_Free( api ); 10eff1: e9 72 e4 ff ff jmp 10d468 <_Workspace_Free> <== NOT EXECUTED 10eff6: 66 90 xchg %ax,%ax <== NOT EXECUTED while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) *(void **)the_thread->Wait.return_argument = value_ptr; if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); 10eff8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10effb: 05 9c 00 00 00 add $0x9c,%eax <== NOT EXECUTED 10f000: 50 push %eax <== NOT EXECUTED 10f001: e8 86 e3 ff ff call 10d38c <_Watchdog_Remove> <== NOT EXECUTED 10f006: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f009: eb cf jmp 10efda <_POSIX_Threads_Delete_extension+0x52> <== NOT EXECUTED 0010ef68 <_POSIX_Threads_Exitted_extension>: */ User_extensions_routine _POSIX_Threads_Exitted_extension( Thread_Control *executing ) { 10ef68: 55 push %ebp <== NOT EXECUTED 10ef69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ef6b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED /* * If the executing thread was not created with the POSIX API, then this * API do not get to define its exit behavior. */ if ( _Objects_Get_API( executing->Object.id ) == OBJECTS_POSIX_API ) 10ef6e: 0f b6 42 0b movzbl 0xb(%edx),%eax <== NOT EXECUTED 10ef72: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 10ef75: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10ef78: 74 02 je 10ef7c <_POSIX_Threads_Exitted_extension+0x14> <== NOT EXECUTED pthread_exit( executing->Wait.return_argument ); } 10ef7a: c9 leave <== NOT EXECUTED 10ef7b: c3 ret <== NOT EXECUTED /* * If the executing thread was not created with the POSIX API, then this * API do not get to define its exit behavior. */ if ( _Objects_Get_API( executing->Object.id ) == OBJECTS_POSIX_API ) pthread_exit( executing->Wait.return_argument ); 10ef7c: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 10ef7f: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10ef82: c9 leave <== NOT EXECUTED /* * If the executing thread was not created with the POSIX API, then this * API do not get to define its exit behavior. */ if ( _Objects_Get_API( executing->Object.id ) == OBJECTS_POSIX_API ) pthread_exit( executing->Wait.return_argument ); 10ef83: e9 e8 17 00 00 jmp 110770 <== NOT EXECUTED 0010ef04 <_POSIX_Threads_Initialize_user_threads>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads( void ) { 10ef04: 55 push %ebp <== NOT EXECUTED 10ef05: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( _POSIX_Threads_Initialize_user_threads_p ) 10ef07: 8b 0d 54 db 11 00 mov 0x11db54,%ecx <== NOT EXECUTED 10ef0d: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ef0f: 74 03 je 10ef14 <_POSIX_Threads_Initialize_user_threads+0x10> <== NOT EXECUTED (*_POSIX_Threads_Initialize_user_threads_p)(); } 10ef11: c9 leave <== NOT EXECUTED */ void _POSIX_Threads_Initialize_user_threads( void ) { if ( _POSIX_Threads_Initialize_user_threads_p ) (*_POSIX_Threads_Initialize_user_threads_p)(); 10ef12: ff e1 jmp *%ecx <== NOT EXECUTED } 10ef14: c9 leave <== NOT EXECUTED 10ef15: c3 ret <== NOT EXECUTED 0010b068 <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body( void ) { 10b068: 55 push %ebp <== NOT EXECUTED 10b069: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b06b: 57 push %edi <== NOT EXECUTED 10b06c: 56 push %esi <== NOT EXECUTED 10b06d: 53 push %ebx <== NOT EXECUTED 10b06e: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED uint32_t maximum; posix_initialization_threads_table *user_threads; pthread_t thread_id; pthread_attr_t attr; user_threads = _POSIX_Threads_User_initialization_threads; 10b071: 8b 3d 40 38 12 00 mov 0x123840,%edi <== NOT EXECUTED maximum = _POSIX_Threads_Number_of_initialization_threads; 10b077: a1 14 39 12 00 mov 0x123914,%eax <== NOT EXECUTED 10b07c: 89 45 b0 mov %eax,-0x50(%ebp) <== NOT EXECUTED if ( !user_threads || maximum == 0 ) 10b07f: 85 ff test %edi,%edi <== NOT EXECUTED 10b081: 74 44 je 10b0c7 <_POSIX_Threads_Initialize_user_threads_body+0x5f> <== NOT EXECUTED 10b083: 85 c0 test %eax,%eax <== NOT EXECUTED 10b085: 74 40 je 10b0c7 <_POSIX_Threads_Initialize_user_threads_body+0x5f> <== NOT EXECUTED 10b087: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b089: 8d 75 b8 lea -0x48(%ebp),%esi <== NOT EXECUTED for ( index=0 ; index < maximum ; index++ ) { /* * There is no way for these calls to fail in this situation. */ (void) pthread_attr_init( &attr ); 10b08c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b08f: 56 push %esi <== NOT EXECUTED 10b090: e8 cb 5d 00 00 call 110e60 <== NOT EXECUTED (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 10b095: 58 pop %eax <== NOT EXECUTED 10b096: 5a pop %edx <== NOT EXECUTED 10b097: 6a 02 push $0x2 <== NOT EXECUTED 10b099: 56 push %esi <== NOT EXECUTED 10b09a: e8 f1 5d 00 00 call 110e90 <== NOT EXECUTED (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size); 10b09f: 59 pop %ecx <== NOT EXECUTED 10b0a0: 58 pop %eax <== NOT EXECUTED 10b0a1: ff 74 df 04 pushl 0x4(%edi,%ebx,8) <== NOT EXECUTED 10b0a5: 56 push %esi <== NOT EXECUTED 10b0a6: e8 19 5e 00 00 call 110ec4 <== NOT EXECUTED status = pthread_create( 10b0ab: 6a 00 push $0x0 <== NOT EXECUTED 10b0ad: ff 34 df pushl (%edi,%ebx,8) <== NOT EXECUTED 10b0b0: 56 push %esi <== NOT EXECUTED 10b0b1: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b0b4: 50 push %eax <== NOT EXECUTED 10b0b5: e8 ea fb ff ff call 10aca4 <== NOT EXECUTED &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) 10b0ba: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10b0bd: 85 c0 test %eax,%eax <== NOT EXECUTED 10b0bf: 75 0f jne 10b0d0 <_POSIX_Threads_Initialize_user_threads_body+0x68> <== NOT EXECUTED * * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { 10b0c1: 43 inc %ebx <== NOT EXECUTED 10b0c2: 39 5d b0 cmp %ebx,-0x50(%ebp) <== NOT EXECUTED 10b0c5: 77 c5 ja 10b08c <_POSIX_Threads_Initialize_user_threads_body+0x24> <== NOT EXECUTED NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, TRUE, status ); } } 10b0c7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b0ca: 5b pop %ebx <== NOT EXECUTED 10b0cb: 5e pop %esi <== NOT EXECUTED 10b0cc: 5f pop %edi <== NOT EXECUTED 10b0cd: c9 leave <== NOT EXECUTED 10b0ce: c3 ret <== NOT EXECUTED 10b0cf: 90 nop <== NOT EXECUTED &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, TRUE, status ); 10b0d0: 52 push %edx <== NOT EXECUTED 10b0d1: 50 push %eax <== NOT EXECUTED 10b0d2: 6a 01 push $0x1 <== NOT EXECUTED 10b0d4: 6a 02 push $0x2 <== NOT EXECUTED 10b0d6: e8 31 21 00 00 call 10d20c <_Internal_error_Occurred> <== NOT EXECUTED 0010ef18 <_POSIX_Threads_Manager_initialization>: uint32_t maximum_pthreads, uint32_t number_of_initialization_threads, posix_initialization_threads_table *user_threads ) { 10ef18: 55 push %ebp <== NOT EXECUTED 10ef19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ef1b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _POSIX_Threads_Number_of_initialization_threads = 10ef1e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ef21: a3 14 fd 11 00 mov %eax,0x11fd14 <== NOT EXECUTED number_of_initialization_threads; _POSIX_Threads_User_initialization_threads = user_threads; 10ef26: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10ef29: a3 40 fc 11 00 mov %eax,0x11fc40 <== NOT EXECUTED #if 0 if ( user_threads == NULL || number_of_initialization_threads == 0 ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, TRUE, EINVAL ); #endif _Objects_Initialize_information( 10ef2e: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10ef33: 6a 01 push $0x1 <== NOT EXECUTED 10ef35: 68 08 01 00 00 push $0x108 <== NOT EXECUTED 10ef3a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ef3d: 6a 01 push $0x1 <== NOT EXECUTED 10ef3f: 6a 03 push $0x3 <== NOT EXECUTED 10ef41: 68 80 fa 11 00 push $0x11fa80 <== NOT EXECUTED 10ef46: e8 21 cc ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED /* * Add all the extensions for this API */ _User_extensions_Add_API_set( &_POSIX_Threads_User_extensions ); 10ef4b: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10ef4e: 68 a0 d5 11 00 push $0x11d5a0 <== NOT EXECUTED 10ef53: e8 0c 10 00 00 call 10ff64 <_User_extensions_Add_API_set> <== NOT EXECUTED _API_extensions_Add( &_POSIX_Threads_API_extensions ); 10ef58: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ef5b: c7 45 08 80 d5 11 00 movl $0x11d580,0x8(%ebp) <== NOT EXECUTED /* * If we supported MP, then here we would ... * Register the MP Process Packet routine. */ } 10ef62: c9 leave <== NOT EXECUTED * Add all the extensions for this API */ _User_extensions_Add_API_set( &_POSIX_Threads_User_extensions ); _API_extensions_Add( &_POSIX_Threads_API_extensions ); 10ef63: e9 8c bd ff ff jmp 10acf4 <_API_extensions_Add> <== NOT EXECUTED 0010f188 <_POSIX_Threads_Sporadic_budget_TSR>: void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id, void *argument ) { 10f188: 55 push %ebp <== NOT EXECUTED 10f189: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f18b: 56 push %esi <== NOT EXECUTED 10f18c: 53 push %ebx <== NOT EXECUTED 10f18d: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Thread_Control *the_thread; POSIX_API_Control *api; the_thread = argument; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10f190: 8b b3 f8 00 00 00 mov 0xf8(%ebx),%esi <== NOT EXECUTED ticks = _Timespec_To_ticks( &api->schedparam.ss_initial_budget ); 10f196: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f199: 8d 86 90 00 00 00 lea 0x90(%esi),%eax <== NOT EXECUTED 10f19f: 50 push %eax <== NOT EXECUTED 10f1a0: e8 5b 0d 00 00 call 10ff00 <_Timespec_To_ticks> <== NOT EXECUTED if ( !ticks ) 10f1a5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f1a8: 85 c0 test %eax,%eax <== NOT EXECUTED 10f1aa: 75 02 jne 10f1ae <_POSIX_Threads_Sporadic_budget_TSR+0x26> <== NOT EXECUTED 10f1ac: b0 01 mov $0x1,%al <== NOT EXECUTED ticks = 1; the_thread->cpu_time_budget = ticks; 10f1ae: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10f1b1: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10f1b6: 2b 86 98 00 00 00 sub 0x98(%esi),%eax <== NOT EXECUTED new_priority = _POSIX_Priority_To_core( api->ss_high_priority ); the_thread->real_priority = new_priority; 10f1bc: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED if ( the_thread->resource_count == 0 || 10f1bf: 8b 4b 1c mov 0x1c(%ebx),%ecx <== NOT EXECUTED 10f1c2: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f1c4: 74 3e je 10f204 <_POSIX_Threads_Sporadic_budget_TSR+0x7c> <== NOT EXECUTED 10f1c6: 39 43 14 cmp %eax,0x14(%ebx) <== NOT EXECUTED 10f1c9: 77 39 ja 10f204 <_POSIX_Threads_Sporadic_budget_TSR+0x7c> <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); ticks = _Timespec_To_ticks( &api->schedparam.ss_replenish_period ); 10f1cb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f1ce: 8d 86 88 00 00 00 lea 0x88(%esi),%eax <== NOT EXECUTED 10f1d4: 50 push %eax <== NOT EXECUTED 10f1d5: e8 26 0d 00 00 call 10ff00 <_Timespec_To_ticks> <== NOT EXECUTED if ( !ticks ) 10f1da: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f1dd: 85 c0 test %eax,%eax <== NOT EXECUTED 10f1df: 75 02 jne 10f1e3 <_POSIX_Threads_Sporadic_budget_TSR+0x5b> <== NOT EXECUTED 10f1e1: b0 01 mov $0x1,%al <== 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, 10f1e3: 89 86 a8 00 00 00 mov %eax,0xa8(%esi) <== NOT EXECUTED void *starting_address, size_t *size 10f1e9: 8d 86 9c 00 00 00 lea 0x9c(%esi),%eax <== NOT EXECUTED 10f1ef: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10f1f2: c7 45 08 9c f8 11 00 movl $0x11f89c,0x8(%ebp) <== NOT EXECUTED ticks = 1; _Watchdog_Insert_ticks( &api->Sporadic_timer, ticks ); } 10f1f9: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f1fc: 5b pop %ebx <== NOT EXECUTED 10f1fd: 5e pop %esi <== NOT EXECUTED 10f1fe: c9 leave <== NOT EXECUTED 10f1ff: e9 58 e0 ff ff jmp 10d25c <_Watchdog_Insert> <== NOT EXECUTED new_priority = _POSIX_Priority_To_core( api->ss_high_priority ); the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); 10f204: 52 push %edx <== NOT EXECUTED 10f205: 6a 01 push $0x1 <== NOT EXECUTED 10f207: 50 push %eax <== NOT EXECUTED 10f208: 53 push %ebx <== NOT EXECUTED 10f209: e8 62 cc ff ff call 10be70 <_Thread_Change_priority> <== NOT EXECUTED 10f20e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f211: eb b8 jmp 10f1cb <_POSIX_Threads_Sporadic_budget_TSR+0x43> <== NOT EXECUTED 0010f148 <_POSIX_Threads_Sporadic_budget_callout>: */ void _POSIX_Threads_Sporadic_budget_callout( Thread_Control *the_thread ) { 10f148: 55 push %ebp <== NOT EXECUTED 10f149: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f14b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f14e: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10f151: 8b 81 f8 00 00 00 mov 0xf8(%ecx),%eax <== NOT EXECUTED * This will prevent the thread from consuming its entire "budget" * while at low priority. */ the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */ 10f157: c7 41 78 ff ff ff ff movl $0xffffffff,0x78(%ecx) <== 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 10f15e: ba ff 00 00 00 mov $0xff,%edx <== NOT EXECUTED 10f163: 2b 90 84 00 00 00 sub 0x84(%eax),%edx <== NOT EXECUTED new_priority = _POSIX_Priority_To_core( api->schedparam.ss_low_priority ); the_thread->real_priority = new_priority; 10f169: 89 51 18 mov %edx,0x18(%ecx) <== NOT EXECUTED if ( the_thread->resource_count == 0 || 10f16c: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 10f16f: 85 c0 test %eax,%eax <== NOT EXECUTED 10f171: 74 05 je 10f178 <_POSIX_Threads_Sporadic_budget_callout+0x30> <== NOT EXECUTED 10f173: 39 51 14 cmp %edx,0x14(%ecx) <== NOT EXECUTED 10f176: 76 0d jbe 10f185 <_POSIX_Threads_Sporadic_budget_callout+0x3d> <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); 10f178: 50 push %eax <== NOT EXECUTED 10f179: 6a 01 push $0x1 <== NOT EXECUTED 10f17b: 52 push %edx <== NOT EXECUTED 10f17c: 51 push %ecx <== NOT EXECUTED 10f17d: e8 ee cc ff ff call 10be70 <_Thread_Change_priority> <== NOT EXECUTED 10f182: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10f185: c9 leave <== NOT EXECUTED 10f186: c3 ret <== NOT EXECUTED 00110444 <_POSIX_Threads_cancel_run>: #include void _POSIX_Threads_cancel_run( Thread_Control *the_thread ) { 110444: 55 push %ebp <== NOT EXECUTED 110445: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110447: 57 push %edi <== NOT EXECUTED 110448: 56 push %esi <== NOT EXECUTED 110449: 53 push %ebx <== NOT EXECUTED 11044a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED POSIX_Cancel_Handler_control *handler; Chain_Control *handler_stack; POSIX_API_Control *thread_support; ISR_Level level; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 11044d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 110450: 8b b8 f8 00 00 00 mov 0xf8(%eax),%edi <== NOT EXECUTED handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; 110456: c7 87 cc 00 00 00 01 movl $0x1,0xcc(%edi) <== NOT EXECUTED 11045d: 00 00 00 <== 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 110460: 8d b7 dc 00 00 00 lea 0xdc(%edi),%esi <== NOT EXECUTED while ( !_Chain_Is_empty( handler_stack ) ) { 110466: 39 b7 d8 00 00 00 cmp %esi,0xd8(%edi) <== NOT EXECUTED 11046c: 74 30 je 11049e <_POSIX_Threads_cancel_run+0x5a> <== NOT EXECUTED 11046e: 66 90 xchg %ax,%ax <== NOT EXECUTED _ISR_Disable( level ); 110470: 9c pushf <== NOT EXECUTED 110471: fa cli <== NOT EXECUTED 110472: 59 pop %ecx <== NOT EXECUTED handler = (POSIX_Cancel_Handler_control *) 110473: 8b 5e 04 mov 0x4(%esi),%ebx <== NOT EXECUTED 110476: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 110478: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 11047b: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 11047e: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 110480: 51 push %ecx <== NOT EXECUTED 110481: 9d popf <== NOT EXECUTED (*handler->routine)( handler->arg ); 110482: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110485: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 110488: ff 53 08 call *0x8(%ebx) <== NOT EXECUTED _Workspace_Free( handler ); 11048b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 11048e: e8 d5 cf ff ff call 10d468 <_Workspace_Free> <== NOT EXECUTED handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; while ( !_Chain_Is_empty( handler_stack ) ) { 110493: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110496: 39 b7 d8 00 00 00 cmp %esi,0xd8(%edi) <== NOT EXECUTED 11049c: 75 d2 jne 110470 <_POSIX_Threads_cancel_run+0x2c> <== NOT EXECUTED (*handler->routine)( handler->arg ); _Workspace_Free( handler ); } } 11049e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1104a1: 5b pop %ebx <== NOT EXECUTED 1104a2: 5e pop %esi <== NOT EXECUTED 1104a3: 5f pop %edi <== NOT EXECUTED 1104a4: c9 leave <== NOT EXECUTED 1104a5: c3 ret <== NOT EXECUTED 0011120c <_POSIX_Timer_Insert_helper>: Watchdog_Interval ticks, Objects_Id id, Watchdog_Service_routine_entry TSR, void *arg ) { 11120c: 55 push %ebp <== NOT EXECUTED 11120d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11120f: 56 push %esi <== NOT EXECUTED 111210: 53 push %ebx <== NOT EXECUTED 111211: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; (void) _Watchdog_Remove( timer ); 111214: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111217: 53 push %ebx <== NOT EXECUTED 111218: e8 bf de ff ff call 10f0dc <_Watchdog_Remove> <== NOT EXECUTED _ISR_Disable( level ); 11121d: 9c pushf <== NOT EXECUTED 11121e: fa cli <== NOT EXECUTED 11121f: 5e pop %esi <== NOT EXECUTED /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( timer->state != WATCHDOG_INACTIVE ) { 111220: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111223: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 111226: 85 c0 test %eax,%eax <== NOT EXECUTED 111228: 74 0e je 111238 <_POSIX_Timer_Insert_helper+0x2c> <== NOT EXECUTED _ISR_Enable( level ); 11122a: 56 push %esi <== NOT EXECUTED 11122b: 9d popf <== NOT EXECUTED 11122c: 31 c0 xor %eax,%eax <== NOT EXECUTED */ _Watchdog_Initialize( timer, TSR, id, arg ); _Watchdog_Insert_ticks( timer, ticks ); _ISR_Enable( level ); return true; } 11122e: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111231: 5b pop %ebx <== NOT EXECUTED 111232: 5e pop %esi <== NOT EXECUTED 111233: c9 leave <== NOT EXECUTED 111234: c3 ret <== NOT EXECUTED 111235: 8d 76 00 lea 0x0(%esi),%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. * 111238: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 11123f: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 111242: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 111245: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 111248: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED * the heap 11124b: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 11124e: 89 43 24 mov %eax,0x24(%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, 111251: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 111254: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 111257: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11125a: 53 push %ebx <== NOT EXECUTED 11125b: 68 1c 3f 12 00 push $0x123f1c <== NOT EXECUTED 111260: e8 47 dd ff ff call 10efac <_Watchdog_Insert> <== NOT EXECUTED * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ _Watchdog_Initialize( timer, TSR, id, arg ); _Watchdog_Insert_ticks( timer, ticks ); _ISR_Enable( level ); 111265: 56 push %esi <== NOT EXECUTED 111266: 9d popf <== NOT EXECUTED 111267: b0 01 mov $0x1,%al <== NOT EXECUTED 111269: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return true; } 11126c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11126f: 5b pop %ebx <== NOT EXECUTED 111270: 5e pop %esi <== NOT EXECUTED 111271: c9 leave <== NOT EXECUTED 111272: c3 ret <== NOT EXECUTED 0010f214 <_POSIX_Timer_Manager_initialization>: * Description: Initialize the internal structure in which the data of all * the timers are stored */ void _POSIX_Timer_Manager_initialization ( int maximum_timers ) { 10f214: 55 push %ebp <== NOT EXECUTED 10f215: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f217: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f21a: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10f21f: 6a 01 push $0x1 <== NOT EXECUTED 10f221: 6a 74 push $0x74 <== NOT EXECUTED 10f223: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f226: 6a 09 push $0x9 <== NOT EXECUTED 10f228: 6a 03 push $0x3 <== NOT EXECUTED 10f22a: 68 40 fb 11 00 push $0x11fb40 <== NOT EXECUTED 10f22f: e8 38 c9 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10f234: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10f237: c9 leave <== NOT EXECUTED 10f238: c3 ret <== NOT EXECUTED 0010b760 <_POSIX_Timer_TSR>: /* * This is the operation that is run when a timer expires */ void _POSIX_Timer_TSR(Objects_Id timer, void *data) { 10b760: 55 push %ebp <== NOT EXECUTED 10b761: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b763: 53 push %ebx <== NOT EXECUTED 10b764: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b767: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 10b76a: ff 43 68 incl 0x68(%ebx) <== NOT EXECUTED /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10b76d: 8b 53 54 mov 0x54(%ebx),%edx <== NOT EXECUTED 10b770: 85 d2 test %edx,%edx <== NOT EXECUTED 10b772: 75 28 jne 10b79c <_POSIX_Timer_TSR+0x3c> <== NOT EXECUTED 10b774: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED 10b777: 85 c0 test %eax,%eax <== NOT EXECUTED 10b779: 75 21 jne 10b79c <_POSIX_Timer_TSR+0x3c> <== NOT EXECUTED /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; } else { /* Indicates that the timer is stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10b77b: c6 43 3c 04 movb $0x4,0x3c(%ebx) <== NOT EXECUTED /* * The sending of the signal to the process running the handling function * specified for that signal is simulated */ if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) { 10b77f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b782: ff 73 44 pushl 0x44(%ebx) <== NOT EXECUTED 10b785: ff 73 38 pushl 0x38(%ebx) <== NOT EXECUTED 10b788: e8 83 57 00 00 call 110f10 <== NOT EXECUTED } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 10b78d: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) <== NOT EXECUTED 10b794: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b797: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b79a: c9 leave <== NOT EXECUTED 10b79b: c3 ret <== NOT EXECUTED ptimer->overrun = ptimer->overrun + 1; /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { activated = _POSIX_Timer_Insert_helper( 10b79c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b79f: 53 push %ebx <== NOT EXECUTED 10b7a0: 68 60 b7 10 00 push $0x10b760 <== NOT EXECUTED 10b7a5: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10b7a8: ff 73 64 pushl 0x64(%ebx) <== NOT EXECUTED 10b7ab: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10b7ae: 50 push %eax <== NOT EXECUTED 10b7af: e8 58 5a 00 00 call 11120c <_POSIX_Timer_Insert_helper> <== NOT EXECUTED ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 10b7b4: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10b7b7: 84 c0 test %al,%al <== NOT EXECUTED 10b7b9: 74 dc je 10b797 <_POSIX_Timer_TSR+0x37> <== NOT EXECUTED return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 10b7bb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b7be: 8d 43 6c lea 0x6c(%ebx),%eax <== NOT EXECUTED 10b7c1: 50 push %eax <== NOT EXECUTED 10b7c2: e8 19 17 00 00 call 10cee0 <_TOD_Get> <== NOT EXECUTED /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10b7c7: c6 43 3c 03 movb $0x3,0x3c(%ebx) <== NOT EXECUTED 10b7cb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b7ce: eb af jmp 10b77f <_POSIX_Timer_TSR+0x1f> <== NOT EXECUTED 0010eecc <_POSIX_signals_Abnormal_termination_handler>: /*** PROCESS WIDE STUFF ****/ sigset_t _POSIX_signals_Pending; void _POSIX_signals_Abnormal_termination_handler( int signo ) { 10eecc: 55 push %ebp <== NOT EXECUTED 10eecd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10eecf: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED exit( 1 ); 10eed2: 6a 01 push $0x1 <== NOT EXECUTED 10eed4: e8 b3 1d 00 00 call 110c8c <== NOT EXECUTED 0010bcb8 <_POSIX_signals_Alarm_TSR>: void _POSIX_signals_Alarm_TSR( Objects_Id id, void *argument ) { 10bcb8: 55 push %ebp <== NOT EXECUTED 10bcb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bcbb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED int status; status = kill( getpid(), SIGALRM ); 10bcbe: e8 89 d5 ff ff call 10924c <== NOT EXECUTED 10bcc3: c7 45 0c 0e 00 00 00 movl $0xe,0xc(%ebp) <== NOT EXECUTED 10bcca: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED /* XXX can't print from an ISR, should this be fatal? */ } 10bccd: c9 leave <== NOT EXECUTED void *argument ) { int status; status = kill( getpid(), SIGALRM ); 10bcce: e9 71 00 00 00 jmp 10bd44 <== NOT EXECUTED 00110550 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) { 110550: 55 push %ebp <== NOT EXECUTED 110551: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110553: 57 push %edi <== NOT EXECUTED 110554: 56 push %esi <== NOT EXECUTED 110555: 53 push %ebx <== NOT EXECUTED 110556: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 110559: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 11055c: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED siginfo_t siginfo_struct; sigset_t saved_signals_blocked; if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct, 11055f: 6a 01 push $0x1 <== NOT EXECUTED 110561: 0f b6 45 10 movzbl 0x10(%ebp),%eax <== NOT EXECUTED 110565: 50 push %eax <== NOT EXECUTED 110566: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 110569: 50 push %eax <== NOT EXECUTED 11056a: 53 push %ebx <== NOT EXECUTED 11056b: 56 push %esi <== NOT EXECUTED 11056c: e8 73 00 00 00 call 1105e4 <_POSIX_signals_Clear_signals> <== NOT EXECUTED 110571: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 110574: 84 c0 test %al,%al <== NOT EXECUTED 110576: 74 4c je 1105c4 <_POSIX_signals_Check_signal+0x74> <== NOT EXECUTED #endif /* * Just to prevent sending a signal which is currently being ignored. */ if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN ) 110578: 8d 04 5b lea (%ebx,%ebx,2),%eax <== NOT EXECUTED 11057b: 8d 14 85 00 00 00 00 lea 0x0(,%eax,4),%edx <== NOT EXECUTED 110582: 8b 8a 08 fe 11 00 mov 0x11fe08(%edx),%ecx <== NOT EXECUTED 110588: 83 f9 01 cmp $0x1,%ecx <== NOT EXECUTED 11058b: 74 37 je 1105c4 <_POSIX_signals_Check_signal+0x74> <== NOT EXECUTED return false; /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 11058d: 8b be c4 00 00 00 mov 0xc4(%esi),%edi <== NOT EXECUTED api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 110593: 89 f8 mov %edi,%eax <== NOT EXECUTED 110595: 0b 82 04 fe 11 00 or 0x11fe04(%edx),%eax <== NOT EXECUTED 11059b: 89 86 c4 00 00 00 mov %eax,0xc4(%esi) <== NOT EXECUTED /* * Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 1105a1: 83 ba 00 fe 11 00 02 cmpl $0x2,0x11fe00(%edx) <== NOT EXECUTED 1105a8: 74 26 je 1105d0 <_POSIX_signals_Check_signal+0x80> <== NOT EXECUTED &siginfo_struct, NULL /* context is undefined per 1003.1b-1993, p. 66 */ ); break; default: (*_POSIX_signals_Vectors[ signo ].sa_handler)( signo ); 1105aa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1105ad: 53 push %ebx <== NOT EXECUTED 1105ae: ff d1 call *%ecx <== NOT EXECUTED 1105b0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 1105b3: 89 be c4 00 00 00 mov %edi,0xc4(%esi) <== NOT EXECUTED 1105b9: b0 01 mov $0x1,%al <== NOT EXECUTED return true; } 1105bb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1105be: 5b pop %ebx <== NOT EXECUTED 1105bf: 5e pop %esi <== NOT EXECUTED 1105c0: 5f pop %edi <== NOT EXECUTED 1105c1: c9 leave <== NOT EXECUTED 1105c2: c3 ret <== NOT EXECUTED 1105c3: 90 nop <== NOT EXECUTED /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; return true; 1105c4: 31 c0 xor %eax,%eax <== NOT EXECUTED } 1105c6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1105c9: 5b pop %ebx <== NOT EXECUTED 1105ca: 5e pop %esi <== NOT EXECUTED 1105cb: 5f pop %edi <== NOT EXECUTED 1105cc: c9 leave <== NOT EXECUTED 1105cd: c3 ret <== NOT EXECUTED 1105ce: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { case SA_SIGINFO: (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 1105d0: 50 push %eax <== NOT EXECUTED 1105d1: 6a 00 push $0x0 <== NOT EXECUTED 1105d3: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 1105d6: 50 push %eax <== NOT EXECUTED 1105d7: 53 push %ebx <== NOT EXECUTED 1105d8: ff 92 08 fe 11 00 call *0x11fe08(%edx) <== NOT EXECUTED 1105de: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1105e1: eb d0 jmp 1105b3 <_POSIX_signals_Check_signal+0x63> <== NOT EXECUTED 00110c44 <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( sigset_t mask ) { 110c44: 55 push %ebp <== NOT EXECUTED 110c45: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110c47: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 110c4a: 9c pushf <== NOT EXECUTED 110c4b: fa cli <== NOT EXECUTED 110c4c: 5a pop %edx <== NOT EXECUTED _POSIX_signals_Pending &= ~mask; 110c4d: f7 d0 not %eax <== NOT EXECUTED 110c4f: 23 05 e0 ff 11 00 and 0x11ffe0,%eax <== NOT EXECUTED 110c55: a3 e0 ff 11 00 mov %eax,0x11ffe0 <== NOT EXECUTED if ( !_POSIX_signals_Pending ) 110c5a: 85 c0 test %eax,%eax <== NOT EXECUTED 110c5c: 75 06 jne 110c64 <_POSIX_signals_Clear_process_signals+0x20> <== NOT EXECUTED _Thread_Do_post_task_switch_extension--; 110c5e: ff 0d 60 f8 11 00 decl 0x11f860 <== NOT EXECUTED _ISR_Enable( level ); 110c64: 52 push %edx <== NOT EXECUTED 110c65: 9d popf <== NOT EXECUTED } 110c66: c9 leave <== NOT EXECUTED 110c67: c3 ret <== NOT EXECUTED 001105e4 <_POSIX_signals_Clear_signals>: int signo, siginfo_t *info, bool is_global, bool check_blocked ) { 1105e4: 55 push %ebp <== NOT EXECUTED 1105e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1105e7: 57 push %edi <== NOT EXECUTED 1105e8: 56 push %esi <== NOT EXECUTED 1105e9: 53 push %ebx <== NOT EXECUTED 1105ea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1105ed: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 1105f0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1105f3: 8a 45 14 mov 0x14(%ebp),%al <== NOT EXECUTED sigset_t signals_blocked; ISR_Level level; bool do_callout; POSIX_signals_Siginfo_node *psiginfo; mask = signo_to_mask( signo ); 1105f6: 8d 4e ff lea -0x1(%esi),%ecx <== NOT EXECUTED 1105f9: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 1105fe: d3 e3 shl %cl,%ebx <== NOT EXECUTED /* set blocked signals based on if checking for them, SIGNAL_ALL_MASK * insures that no signals are blocked and all are checked. */ if ( check_blocked ) 110600: 80 7d 18 00 cmpb $0x0,0x18(%ebp) <== NOT EXECUTED 110604: 0f 85 9e 00 00 00 jne 1106a8 <_POSIX_signals_Clear_signals+0xc4> <== NOT EXECUTED 11060a: ba ff ff ff ff mov $0xffffffff,%edx <== NOT EXECUTED signals_blocked = SIGNAL_ALL_MASK; /* XXX this is not right for siginfo type signals yet */ /* XXX since they can't be cleared the same way */ _ISR_Disable( level ); 11060f: 9c pushf <== NOT EXECUTED 110610: fa cli <== NOT EXECUTED 110611: 8f 45 f0 popl -0x10(%ebp) <== NOT EXECUTED if ( is_global ) { 110614: 84 c0 test %al,%al <== NOT EXECUTED 110616: 0f 84 9c 00 00 00 je 1106b8 <_POSIX_signals_Clear_signals+0xd4> <== NOT EXECUTED if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { 11061c: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11061e: 23 05 e0 ff 11 00 and 0x11ffe0,%eax <== NOT EXECUTED 110624: 85 d0 test %edx,%eax <== NOT EXECUTED 110626: 0f 84 b4 00 00 00 je 1106e0 <_POSIX_signals_Clear_signals+0xfc> <== NOT EXECUTED if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 11062c: 8d 04 76 lea (%esi,%esi,2),%eax <== NOT EXECUTED 11062f: 8d 14 85 00 00 00 00 lea 0x0(,%eax,4),%edx <== NOT EXECUTED 110636: 83 ba 00 fe 11 00 02 cmpl $0x2,0x11fe00(%edx) <== NOT EXECUTED 11063d: 0f 85 a1 00 00 00 jne 1106e4 <_POSIX_signals_Clear_signals+0x100> <== NOT EXECUTED psiginfo = (POSIX_signals_Siginfo_node *) 110643: 8d ba 00 00 12 00 lea 0x120000(%edx),%edi <== 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( 110649: 8b 8a 00 00 12 00 mov 0x120000(%edx),%ecx <== 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 11064f: 8d 77 04 lea 0x4(%edi),%esi <== NOT EXECUTED 110652: 39 f1 cmp %esi,%ecx <== NOT EXECUTED 110654: 0f 84 9a 00 00 00 je 1106f4 <_POSIX_signals_Clear_signals+0x110> <== NOT EXECUTED 11065a: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 11065c: 89 82 00 00 12 00 mov %eax,0x120000(%edx) <== NOT EXECUTED 110662: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED 110665: 89 4d e8 mov %ecx,-0x18(%ebp) <== NOT EXECUTED _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] ); if ( _Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 110668: 39 c6 cmp %eax,%esi <== NOT EXECUTED 11066a: 0f 84 8b 00 00 00 je 1106fb <_POSIX_signals_Clear_signals+0x117> <== NOT EXECUTED _POSIX_signals_Clear_process_signals( mask ); if ( psiginfo ) { 110670: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 110673: 85 c0 test %eax,%eax <== NOT EXECUTED 110675: 74 2c je 1106a3 <_POSIX_signals_Clear_signals+0xbf> <== NOT EXECUTED *info = psiginfo->Info; 110677: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 11067a: 83 c6 08 add $0x8,%esi <== NOT EXECUTED 11067d: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 110682: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 110685: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 110687: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 11068a: c7 00 84 ff 11 00 movl $0x11ff84,(%eax) <== NOT EXECUTED 110690: a1 88 ff 11 00 mov 0x11ff88,%eax <== NOT EXECUTED 110695: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 110698: 89 15 88 ff 11 00 mov %edx,0x11ff88 <== NOT EXECUTED 11069e: 89 10 mov %edx,(%eax) <== NOT EXECUTED 1106a0: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 1106a3: b0 01 mov $0x1,%al <== NOT EXECUTED 1106a5: eb 2d jmp 1106d4 <_POSIX_signals_Clear_signals+0xf0> <== NOT EXECUTED 1106a7: 90 nop <== NOT EXECUTED /* set blocked signals based on if checking for them, SIGNAL_ALL_MASK * insures that no signals are blocked and all are checked. */ if ( check_blocked ) signals_blocked = ~api->signals_blocked; 1106a8: 8b 97 c4 00 00 00 mov 0xc4(%edi),%edx <== NOT EXECUTED 1106ae: f7 d2 not %edx <== NOT EXECUTED 1106b0: e9 5a ff ff ff jmp 11060f <_POSIX_signals_Clear_signals+0x2b> <== NOT EXECUTED 1106b5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } else _POSIX_signals_Clear_process_signals( mask ); do_callout = true; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { 1106b8: 8b 8f c8 00 00 00 mov 0xc8(%edi),%ecx <== NOT EXECUTED 1106be: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1106c0: 21 c8 and %ecx,%eax <== NOT EXECUTED 1106c2: 85 d0 test %edx,%eax <== NOT EXECUTED 1106c4: 74 1a je 1106e0 <_POSIX_signals_Clear_signals+0xfc> <== NOT EXECUTED api->signals_pending &= ~mask; 1106c6: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1106c8: f7 d0 not %eax <== NOT EXECUTED 1106ca: 21 c8 and %ecx,%eax <== NOT EXECUTED 1106cc: 89 87 c8 00 00 00 mov %eax,0xc8(%edi) <== NOT EXECUTED 1106d2: b0 01 mov $0x1,%al <== NOT EXECUTED do_callout = true; } } _ISR_Enable( level ); 1106d4: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 1106d7: 9d popf <== NOT EXECUTED return do_callout; } 1106d8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1106db: 5b pop %ebx <== NOT EXECUTED 1106dc: 5e pop %esi <== NOT EXECUTED 1106dd: 5f pop %edi <== NOT EXECUTED 1106de: c9 leave <== NOT EXECUTED 1106df: c3 ret <== NOT EXECUTED _POSIX_signals_Clear_process_signals( mask ); do_callout = true; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { api->signals_pending &= ~mask; 1106e0: 31 c0 xor %eax,%eax <== NOT EXECUTED 1106e2: eb f0 jmp 1106d4 <_POSIX_signals_Clear_signals+0xf0> <== NOT EXECUTED &psiginfo->Node ); } else do_callout = false; } else _POSIX_signals_Clear_process_signals( mask ); 1106e4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1106e7: 53 push %ebx <== NOT EXECUTED 1106e8: e8 57 05 00 00 call 110c44 <_POSIX_signals_Clear_process_signals> <== NOT EXECUTED 1106ed: b0 01 mov $0x1,%al <== NOT EXECUTED 1106ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1106f2: eb e0 jmp 1106d4 <_POSIX_signals_Clear_signals+0xf0> <== NOT EXECUTED 1106f4: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp) <== NOT EXECUTED if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] ); if ( _Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) _POSIX_signals_Clear_process_signals( mask ); 1106fb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1106fe: 53 push %ebx <== NOT EXECUTED 1106ff: e8 40 05 00 00 call 110c44 <_POSIX_signals_Clear_process_signals> <== NOT EXECUTED 110704: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110707: e9 64 ff ff ff jmp 110670 <_POSIX_signals_Clear_signals+0x8c> <== NOT EXECUTED 0010ad7c <_POSIX_signals_Get_highest>: #include int _POSIX_signals_Get_highest( sigset_t set ) { 10ad7c: 55 push %ebp <== NOT EXECUTED 10ad7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad7f: 56 push %esi <== NOT EXECUTED 10ad80: 53 push %ebx <== NOT EXECUTED 10ad81: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10ad84: b8 1b 00 00 00 mov $0x1b,%eax <== NOT EXECUTED int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) 10ad89: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10ad8e: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED 10ad91: 89 d6 mov %edx,%esi <== NOT EXECUTED 10ad93: d3 e6 shl %cl,%esi <== NOT EXECUTED 10ad95: 85 de test %ebx,%esi <== NOT EXECUTED 10ad97: 75 20 jne 10adb9 <_POSIX_signals_Get_highest+0x3d> <== NOT EXECUTED sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10ad99: 40 inc %eax <== NOT EXECUTED 10ad9a: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED 10ad9d: 75 ef jne 10ad8e <_POSIX_signals_Get_highest+0x12> <== NOT EXECUTED 10ad9f: b0 01 mov $0x1,%al <== NOT EXECUTED } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { if ( set & signo_to_mask( signo ) ) 10ada1: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10ada6: eb 06 jmp 10adae <_POSIX_signals_Get_highest+0x32> <== NOT EXECUTED return signo; } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10ada8: 40 inc %eax <== NOT EXECUTED 10ada9: 83 f8 1b cmp $0x1b,%eax <== NOT EXECUTED 10adac: 74 12 je 10adc0 <_POSIX_signals_Get_highest+0x44> <== NOT EXECUTED if ( set & signo_to_mask( signo ) ) 10adae: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED 10adb1: 89 d6 mov %edx,%esi <== NOT EXECUTED 10adb3: d3 e6 shl %cl,%esi <== NOT EXECUTED 10adb5: 85 de test %ebx,%esi <== NOT EXECUTED 10adb7: 74 ef je 10ada8 <_POSIX_signals_Get_highest+0x2c> <== NOT EXECUTED return signo; } return 0; } 10adb9: 5b pop %ebx <== NOT EXECUTED 10adba: 5e pop %esi <== NOT EXECUTED 10adbb: c9 leave <== NOT EXECUTED 10adbc: c3 ret <== NOT EXECUTED 10adbd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return signo; } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10adc0: 30 c0 xor %al,%al <== NOT EXECUTED if ( set & signo_to_mask( signo ) ) return signo; } return 0; } 10adc2: 5b pop %ebx <== NOT EXECUTED 10adc3: 5e pop %esi <== NOT EXECUTED 10adc4: c9 leave <== NOT EXECUTED 10adc5: c3 ret <== NOT EXECUTED 0010ed84 <_POSIX_signals_Manager_Initialization>: */ void _POSIX_signals_Manager_Initialization( int maximum_queued_signals ) { 10ed84: 55 push %ebp <== NOT EXECUTED 10ed85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ed87: 57 push %edi <== NOT EXECUTED 10ed88: 56 push %esi <== NOT EXECUTED 10ed89: 53 push %ebx <== NOT EXECUTED 10ed8a: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10ed8d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED assert( sizeof(_POSIX_signals_Vectors) == sizeof(_POSIX_signals_Default_vectors) ); memcpy( 10ed90: bf 00 fe 11 00 mov $0x11fe00,%edi <== NOT EXECUTED 10ed95: be a0 95 11 00 mov $0x1195a0,%esi <== NOT EXECUTED 10ed9a: b9 60 00 00 00 mov $0x60,%ecx <== NOT EXECUTED 10ed9f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* * Initialize the set of pending signals for the entire process */ sigemptyset( &_POSIX_signals_Pending ); 10eda1: 68 e0 ff 11 00 push $0x11ffe0 <== NOT EXECUTED 10eda6: e8 b9 04 00 00 call 10f264 <== NOT EXECUTED /* * Initialize the queue we use to block for signals */ _Thread_queue_Initialize( 10edab: 6a 0b push $0xb <== NOT EXECUTED 10edad: 68 00 80 00 10 push $0x10008000 <== NOT EXECUTED 10edb2: 6a 01 push $0x1 <== NOT EXECUTED 10edb4: 68 a0 ff 11 00 push $0x11ffa0 <== NOT EXECUTED 10edb9: e8 c2 dc ff ff call 10ca80 <_Thread_queue_Initialize> <== NOT EXECUTED 10edbe: ba 0c 00 12 00 mov $0x12000c,%edx <== NOT EXECUTED 10edc3: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10edc6: 66 90 xchg %ax,%ax <== NOT EXECUTED 10edc8: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10edcb: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10edcd: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10edd4: 89 52 08 mov %edx,0x8(%edx) <== NOT EXECUTED 10edd7: 83 c2 0c add $0xc,%edx <== NOT EXECUTED /* * Allocate the siginfo pools. */ for ( signo=1 ; signo<= SIGRTMAX ; signo++ ) 10edda: 81 fa 80 01 12 00 cmp $0x120180,%edx <== NOT EXECUTED 10ede0: 75 e6 jne 10edc8 <_POSIX_signals_Manager_Initialization+0x44> <== NOT EXECUTED _Chain_Initialize_empty( &_POSIX_signals_Siginfo[ signo ] ); if ( maximum_queued_signals ) { 10ede2: 85 db test %ebx,%ebx <== NOT EXECUTED 10ede4: 75 26 jne 10ee0c <_POSIX_signals_Manager_Initialization+0x88> <== NOT EXECUTED 10ede6: c7 05 80 ff 11 00 84 movl $0x11ff84,0x11ff80 <== NOT EXECUTED 10eded: ff 11 00 <== NOT EXECUTED 10edf0: c7 05 84 ff 11 00 00 movl $0x0,0x11ff84 <== NOT EXECUTED 10edf7: 00 00 00 <== NOT EXECUTED 10edfa: c7 05 88 ff 11 00 80 movl $0x11ff80,0x11ff88 <== NOT EXECUTED 10ee01: ff 11 00 <== NOT EXECUTED sizeof( POSIX_signals_Siginfo_node ) ); } else { _Chain_Initialize_empty( &_POSIX_signals_Inactive_siginfo ); } } 10ee04: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ee07: 5b pop %ebx <== NOT EXECUTED 10ee08: 5e pop %esi <== NOT EXECUTED 10ee09: 5f pop %edi <== NOT EXECUTED 10ee0a: c9 leave <== NOT EXECUTED 10ee0b: c3 ret <== NOT EXECUTED for ( signo=1 ; signo<= SIGRTMAX ; signo++ ) _Chain_Initialize_empty( &_POSIX_signals_Siginfo[ signo ] ); if ( maximum_queued_signals ) { _Chain_Initialize( 10ee0c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ee0f: 8d 04 9b lea (%ebx,%ebx,4),%eax <== NOT EXECUTED 10ee12: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10ee15: 50 push %eax <== NOT EXECUTED 10ee16: e8 7d e6 ff ff call 10d498 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10ee1b: 6a 14 push $0x14 <== NOT EXECUTED 10ee1d: 53 push %ebx <== NOT EXECUTED 10ee1e: 50 push %eax <== NOT EXECUTED 10ee1f: 68 80 ff 11 00 push $0x11ff80 <== NOT EXECUTED 10ee24: e8 a7 08 00 00 call 10f6d0 <_Chain_Initialize> <== NOT EXECUTED 10ee29: 83 c4 20 add $0x20,%esp <== NOT EXECUTED sizeof( POSIX_signals_Siginfo_node ) ); } else { _Chain_Initialize_empty( &_POSIX_signals_Inactive_siginfo ); } } 10ee2c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ee2f: 5b pop %ebx <== NOT EXECUTED 10ee30: 5e pop %esi <== NOT EXECUTED 10ee31: 5f pop %edi <== NOT EXECUTED 10ee32: c9 leave <== NOT EXECUTED 10ee33: c3 ret <== NOT EXECUTED 0010ee34 <_POSIX_signals_Post_switch_extension>: */ void _POSIX_signals_Post_switch_extension( Thread_Control *the_thread ) { 10ee34: 55 push %ebp <== NOT EXECUTED 10ee35: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ee37: 56 push %esi <== NOT EXECUTED 10ee38: 53 push %ebx <== NOT EXECUTED POSIX_API_Control *api; int signo; ISR_Level level; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10ee39: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ee3c: 8b b0 f8 00 00 00 mov 0xf8(%eax),%esi <== NOT EXECUTED if ( !api ) 10ee42: 85 f6 test %esi,%esi <== NOT EXECUTED 10ee44: 74 7c je 10eec2 <_POSIX_signals_Post_switch_extension+0x8e> <== NOT EXECUTED 10ee46: 66 90 xchg %ax,%ax <== NOT EXECUTED * The first thing done is to check there are any signals to be * processed at all. No point in doing this loop otherwise. */ while (1) { restart: _ISR_Disable( level ); 10ee48: 9c pushf <== NOT EXECUTED 10ee49: fa cli <== NOT EXECUTED 10ee4a: 59 pop %ecx <== NOT EXECUTED if ( !(~api->signals_blocked & 10ee4b: 8b 15 e0 ff 11 00 mov 0x11ffe0,%edx <== NOT EXECUTED 10ee51: 0b 96 c8 00 00 00 or 0xc8(%esi),%edx <== NOT EXECUTED 10ee57: 8b 86 c4 00 00 00 mov 0xc4(%esi),%eax <== NOT EXECUTED 10ee5d: f7 d0 not %eax <== NOT EXECUTED 10ee5f: 85 c2 test %eax,%edx <== NOT EXECUTED 10ee61: 74 5d je 10eec0 <_POSIX_signals_Post_switch_extension+0x8c> <== NOT EXECUTED (api->signals_pending | _POSIX_signals_Pending)) ) { _ISR_Enable( level ); break; } _ISR_Enable( level ); 10ee63: 51 push %ecx <== NOT EXECUTED 10ee64: 9d popf <== NOT EXECUTED 10ee65: bb 1b 00 00 00 mov $0x1b,%ebx <== NOT EXECUTED for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( _POSIX_signals_Check_signal( api, signo, false ) ) 10ee6a: 50 push %eax <== NOT EXECUTED 10ee6b: 6a 00 push $0x0 <== NOT EXECUTED 10ee6d: 53 push %ebx <== NOT EXECUTED 10ee6e: 56 push %esi <== NOT EXECUTED 10ee6f: e8 dc 16 00 00 call 110550 <_POSIX_signals_Check_signal> <== NOT EXECUTED 10ee74: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ee77: 84 c0 test %al,%al <== NOT EXECUTED 10ee79: 75 cd jne 10ee48 <_POSIX_signals_Post_switch_extension+0x14> <== NOT EXECUTED goto restart; if ( _POSIX_signals_Check_signal( api, signo, true ) ) 10ee7b: 51 push %ecx <== NOT EXECUTED 10ee7c: 6a 01 push $0x1 <== NOT EXECUTED 10ee7e: 53 push %ebx <== NOT EXECUTED 10ee7f: 56 push %esi <== NOT EXECUTED 10ee80: e8 cb 16 00 00 call 110550 <_POSIX_signals_Check_signal> <== NOT EXECUTED 10ee85: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ee88: 84 c0 test %al,%al <== NOT EXECUTED 10ee8a: 75 bc jne 10ee48 <_POSIX_signals_Post_switch_extension+0x14> <== NOT EXECUTED _ISR_Enable( level ); break; } _ISR_Enable( level ); for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10ee8c: 43 inc %ebx <== NOT EXECUTED 10ee8d: 83 fb 20 cmp $0x20,%ebx <== NOT EXECUTED 10ee90: 75 d8 jne 10ee6a <_POSIX_signals_Post_switch_extension+0x36> <== NOT EXECUTED 10ee92: b3 01 mov $0x1,%bl <== NOT EXECUTED /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { if ( _POSIX_signals_Check_signal( api, signo, false ) ) 10ee94: 52 push %edx <== NOT EXECUTED 10ee95: 6a 00 push $0x0 <== NOT EXECUTED 10ee97: 53 push %ebx <== NOT EXECUTED 10ee98: 56 push %esi <== NOT EXECUTED 10ee99: e8 b2 16 00 00 call 110550 <_POSIX_signals_Check_signal> <== NOT EXECUTED 10ee9e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eea1: 84 c0 test %al,%al <== NOT EXECUTED 10eea3: 75 a3 jne 10ee48 <_POSIX_signals_Post_switch_extension+0x14> <== NOT EXECUTED goto restart; if ( _POSIX_signals_Check_signal( api, signo, true ) ) 10eea5: 50 push %eax <== NOT EXECUTED 10eea6: 6a 01 push $0x1 <== NOT EXECUTED 10eea8: 53 push %ebx <== NOT EXECUTED 10eea9: 56 push %esi <== NOT EXECUTED 10eeaa: e8 a1 16 00 00 call 110550 <_POSIX_signals_Check_signal> <== NOT EXECUTED 10eeaf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eeb2: 84 c0 test %al,%al <== NOT EXECUTED 10eeb4: 75 92 jne 10ee48 <_POSIX_signals_Post_switch_extension+0x14> <== NOT EXECUTED } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10eeb6: 43 inc %ebx <== NOT EXECUTED 10eeb7: 83 fb 1b cmp $0x1b,%ebx <== NOT EXECUTED 10eeba: 75 d8 jne 10ee94 <_POSIX_signals_Post_switch_extension+0x60> <== NOT EXECUTED 10eebc: eb 8a jmp 10ee48 <_POSIX_signals_Post_switch_extension+0x14> <== NOT EXECUTED 10eebe: 66 90 xchg %ax,%ax <== NOT EXECUTED while (1) { restart: _ISR_Disable( level ); if ( !(~api->signals_blocked & (api->signals_pending | _POSIX_signals_Pending)) ) { _ISR_Enable( level ); 10eec0: 51 push %ecx <== NOT EXECUTED 10eec1: 9d popf <== NOT EXECUTED goto restart; } } return; } 10eec2: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10eec5: 5b pop %ebx <== NOT EXECUTED 10eec6: 5e pop %esi <== NOT EXECUTED 10eec7: c9 leave <== NOT EXECUTED 10eec8: c3 ret <== NOT EXECUTED 00121e48 <_POSIX_signals_Set_process_signals>: */ void _POSIX_signals_Set_process_signals( sigset_t mask ) { 121e48: 55 push %ebp <== NOT EXECUTED 121e49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121e4b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 121e4e: 9c pushf <== NOT EXECUTED 121e4f: fa cli <== NOT EXECUTED 121e50: 59 pop %ecx <== NOT EXECUTED if ( !_POSIX_signals_Pending ) 121e51: 8b 15 60 e5 12 00 mov 0x12e560,%edx <== NOT EXECUTED 121e57: 85 d2 test %edx,%edx <== NOT EXECUTED 121e59: 75 06 jne 121e61 <_POSIX_signals_Set_process_signals+0x19> <== NOT EXECUTED _Thread_Do_post_task_switch_extension++; 121e5b: ff 05 60 dd 12 00 incl 0x12dd60 <== NOT EXECUTED _POSIX_signals_Pending |= mask; 121e61: 09 d0 or %edx,%eax <== NOT EXECUTED 121e63: a3 60 e5 12 00 mov %eax,0x12e560 <== NOT EXECUTED _ISR_Enable( level ); 121e68: 51 push %ecx <== NOT EXECUTED 121e69: 9d popf <== NOT EXECUTED } 121e6a: c9 leave <== NOT EXECUTED 121e6b: c3 ret <== NOT EXECUTED 0010a084 <_POSIX_signals_Ualarm_TSR>: void _POSIX_signals_Ualarm_TSR( Objects_Id id, void *argument ) { 10a084: 55 push %ebp <== NOT EXECUTED 10a085: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a087: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED /* * Send a SIGALRM but if there is a problem, ignore it. * It's OK, there isn't a way this should fail. */ (void) kill( getpid(), SIGALRM ); 10a08a: e8 9d d2 ff ff call 10732c <== NOT EXECUTED 10a08f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a092: 6a 0e push $0xe <== NOT EXECUTED 10a094: 50 push %eax <== NOT EXECUTED 10a095: e8 ca fc ff ff call 109d64 <== NOT EXECUTED Heap_Control *the_heap, Heap_Information_block *the_info ); /** * This heap routine returns information about the free blocks 10a09a: c7 04 24 a0 21 12 00 movl $0x1221a0,(%esp) <== NOT EXECUTED 10a0a1: e8 ae 39 00 00 call 10da54 <_Watchdog_Remove> <== NOT EXECUTED * in the specified heap. * 10a0a6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a0a9: c7 45 0c a0 21 12 00 movl $0x1221a0,0xc(%ebp) <== NOT EXECUTED 10a0b0: c7 45 08 7c 23 12 00 movl $0x12237c,0x8(%ebp) <== NOT EXECUTED /* * If the reset interval is non-zero, reschedule ourselves. */ _Watchdog_Reset( &_POSIX_signals_Ualarm_timer ); } 10a0b7: c9 leave <== NOT EXECUTED 10a0b8: e9 67 38 00 00 jmp 10d924 <_Watchdog_Insert> <== NOT EXECUTED 00121e6c <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 121e6c: 55 push %ebp <== NOT EXECUTED 121e6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121e6f: 57 push %edi <== NOT EXECUTED 121e70: 56 push %esi <== NOT EXECUTED 121e71: 53 push %ebx <== NOT EXECUTED 121e72: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 121e75: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 121e78: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED POSIX_API_Control *api; sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 121e7b: 8b bb f8 00 00 00 mov 0xf8(%ebx),%edi <== NOT EXECUTED mask = signo_to_mask( signo ); 121e81: 8d 4e ff lea -0x1(%esi),%ecx <== NOT EXECUTED 121e84: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 121e89: d3 e2 shl %cl,%edx <== NOT EXECUTED /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 121e8b: 8b 4b 10 mov 0x10(%ebx),%ecx <== NOT EXECUTED 121e8e: 89 c8 mov %ecx,%eax <== NOT EXECUTED 121e90: 25 00 80 00 10 and $0x10008000,%eax <== NOT EXECUTED 121e95: 3d 00 80 00 10 cmp $0x10008000,%eax <== NOT EXECUTED 121e9a: 74 70 je 121f0c <_POSIX_signals_Unblock_thread+0xa0> <== NOT EXECUTED } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 121e9c: 8b 87 c4 00 00 00 mov 0xc4(%edi),%eax <== NOT EXECUTED 121ea2: f7 d0 not %eax <== NOT EXECUTED 121ea4: 85 c2 test %eax,%edx <== NOT EXECUTED 121ea6: 74 58 je 121f00 <_POSIX_signals_Unblock_thread+0x94> <== NOT EXECUTED * it is not blocked, THEN * we need to dispatch at the end of this ISR. * + Any other combination, do nothing. */ the_thread->do_post_task_switch_extension = true; 121ea8: c6 43 75 01 movb $0x1,0x75(%ebx) <== NOT EXECUTED if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) { 121eac: f7 c1 00 00 00 10 test $0x10000000,%ecx <== NOT EXECUTED 121eb2: 74 34 je 121ee8 <_POSIX_signals_Unblock_thread+0x7c> <== NOT EXECUTED the_thread->Wait.return_code = EINTR; 121eb4: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) <== NOT EXECUTED #if 0 if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) _Thread_queue_Extract_with_proxy( the_thread ); else #endif if ( _States_Is_delaying(the_thread->current_state) ){ 121ebb: 83 e1 08 and $0x8,%ecx <== NOT EXECUTED 121ebe: 74 40 je 121f00 <_POSIX_signals_Unblock_thread+0x94> <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 121ec0: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 121ec4: 0f 84 aa 00 00 00 je 121f74 <_POSIX_signals_Unblock_thread+0x108> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 121eca: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 121ecd: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 121ed2: 53 push %ebx <== NOT EXECUTED 121ed3: e8 d8 ee fe ff call 110db0 <_Thread_Clear_state> <== NOT EXECUTED 121ed8: 31 c0 xor %eax,%eax <== NOT EXECUTED 121eda: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _ISR_Signals_to_thread_executing = TRUE; } } return false; } 121edd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 121ee0: 5b pop %ebx <== NOT EXECUTED 121ee1: 5e pop %esi <== NOT EXECUTED 121ee2: 5f pop %edi <== NOT EXECUTED 121ee3: c9 leave <== NOT EXECUTED 121ee4: c3 ret <== NOT EXECUTED 121ee5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( _States_Is_delaying(the_thread->current_state) ){ if ( _Watchdog_Is_active( &the_thread->Timer ) ) (void) _Watchdog_Remove( &the_thread->Timer ); _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { 121ee8: 85 c9 test %ecx,%ecx <== NOT EXECUTED 121eea: 75 14 jne 121f00 <_POSIX_signals_Unblock_thread+0x94> <== NOT EXECUTED if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 121eec: a1 58 dd 12 00 mov 0x12dd58,%eax <== NOT EXECUTED 121ef1: 85 c0 test %eax,%eax <== NOT EXECUTED 121ef3: 74 0b je 121f00 <_POSIX_signals_Unblock_thread+0x94> <== NOT EXECUTED 121ef5: 3b 1d 7c dd 12 00 cmp 0x12dd7c,%ebx <== NOT EXECUTED 121efb: 74 55 je 121f52 <_POSIX_signals_Unblock_thread+0xe6> <== NOT EXECUTED 121efd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 121f00: 31 c0 xor %eax,%eax <== NOT EXECUTED } } return false; } 121f02: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 121f05: 5b pop %ebx <== NOT EXECUTED 121f06: 5e pop %esi <== NOT EXECUTED 121f07: 5f pop %edi <== NOT EXECUTED 121f08: c9 leave <== NOT EXECUTED 121f09: c3 ret <== NOT EXECUTED 121f0a: 66 90 xchg %ax,%ax <== NOT EXECUTED * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 121f0c: 85 53 30 test %edx,0x30(%ebx) <== NOT EXECUTED 121f0f: 74 33 je 121f44 <_POSIX_signals_Unblock_thread+0xd8> <== NOT EXECUTED the_thread->Wait.return_code = EINTR; 121f11: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) <== NOT EXECUTED the_info = (siginfo_t *) the_thread->Wait.return_argument; 121f18: 8b 7b 28 mov 0x28(%ebx),%edi <== NOT EXECUTED if ( !info ) { 121f1b: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 121f1e: 85 c0 test %eax,%eax <== NOT EXECUTED 121f20: 74 3e je 121f60 <_POSIX_signals_Unblock_thread+0xf4> <== NOT EXECUTED the_info->si_signo = signo; the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; } else { *the_info = *info; 121f22: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 121f27: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 121f2a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED } _Thread_queue_Extract_with_proxy( the_thread ); 121f2c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 121f2f: 53 push %ebx <== NOT EXECUTED 121f30: e8 2b f9 fe ff call 111860 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 121f35: b0 01 mov $0x1,%al <== NOT EXECUTED 121f37: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _ISR_Signals_to_thread_executing = TRUE; } } return false; } 121f3a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 121f3d: 5b pop %ebx <== NOT EXECUTED 121f3e: 5e pop %esi <== NOT EXECUTED 121f3f: 5f pop %edi <== NOT EXECUTED 121f40: c9 leave <== NOT EXECUTED 121f41: c3 ret <== NOT EXECUTED 121f42: 66 90 xchg %ax,%ax <== NOT EXECUTED * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 121f44: 8b 87 c4 00 00 00 mov 0xc4(%edi),%eax <== NOT EXECUTED 121f4a: f7 d0 not %eax <== NOT EXECUTED 121f4c: 85 c2 test %eax,%edx <== NOT EXECUTED 121f4e: 75 c1 jne 121f11 <_POSIX_signals_Unblock_thread+0xa5> <== NOT EXECUTED 121f50: eb ae jmp 121f00 <_POSIX_signals_Unblock_thread+0x94> <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _ISR_Signals_to_thread_executing = TRUE; 121f52: c6 05 28 de 12 00 01 movb $0x1,0x12de28 <== NOT EXECUTED 121f59: 31 c0 xor %eax,%eax <== NOT EXECUTED 121f5b: eb a5 jmp 121f02 <_POSIX_signals_Unblock_thread+0x96> <== NOT EXECUTED 121f5d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_thread->Wait.return_code = EINTR; the_info = (siginfo_t *) the_thread->Wait.return_argument; if ( !info ) { the_info->si_signo = signo; 121f60: 89 37 mov %esi,(%edi) <== NOT EXECUTED the_info->si_code = SI_USER; 121f62: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) <== NOT EXECUTED the_info->si_value.sival_int = 0; 121f69: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) <== NOT EXECUTED 121f70: eb ba jmp 121f2c <_POSIX_signals_Unblock_thread+0xc0> <== NOT EXECUTED 121f72: 66 90 xchg %ax,%ax <== NOT EXECUTED _Thread_queue_Extract_with_proxy( the_thread ); else #endif if ( _States_Is_delaying(the_thread->current_state) ){ if ( _Watchdog_Is_active( &the_thread->Timer ) ) (void) _Watchdog_Remove( &the_thread->Timer ); 121f74: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 121f77: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 121f7a: 50 push %eax <== NOT EXECUTED 121f7b: e8 d4 02 ff ff call 112254 <_Watchdog_Remove> <== NOT EXECUTED 121f80: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121f83: e9 42 ff ff ff jmp 121eca <_POSIX_signals_Unblock_thread+0x5e> <== NOT EXECUTED 0010f318 <_Partition_Manager_initialization>: */ void _Partition_Manager_initialization( uint32_t maximum_partitions ) { 10f318: 55 push %ebp <== NOT EXECUTED 10f319: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f31b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f31e: 6a 04 push $0x4 <== NOT EXECUTED 10f320: 6a 00 push $0x0 <== NOT EXECUTED 10f322: 6a 30 push $0x30 <== NOT EXECUTED 10f324: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f327: 6a 05 push $0x5 <== NOT EXECUTED 10f329: 6a 02 push $0x2 <== NOT EXECUTED 10f32b: 68 c0 02 12 00 push $0x1202c0 <== NOT EXECUTED 10f330: e8 37 c8 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10f335: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_PARTITION, _Partition_MP_Process_packet ); #endif } 10f338: c9 leave <== NOT EXECUTED 10f339: c3 ret <== NOT EXECUTED 0010bdbc <_Protected_heap_Allocate>: void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ) { 10bdbc: 55 push %ebp <== NOT EXECUTED 10bdbd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bdbf: 53 push %ebx <== NOT EXECUTED 10bdc0: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED void *p; _RTEMS_Lock_allocator(); 10bdc3: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10bdc9: e8 9a ef ff ff call 10ad68 <_API_Mutex_Lock> <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 10bdce: 5a pop %edx <== NOT EXECUTED 10bdcf: 59 pop %ecx <== NOT EXECUTED 10bdd0: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10bdd3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bdd6: e8 61 3b 00 00 call 10f93c <_Heap_Allocate> <== NOT EXECUTED 10bddb: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10bddd: 58 pop %eax <== NOT EXECUTED 10bdde: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10bde4: e8 c7 ef ff ff call 10adb0 <_API_Mutex_Unlock> <== NOT EXECUTED return p; } 10bde9: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bdeb: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bdee: c9 leave <== NOT EXECUTED 10bdef: c3 ret <== NOT EXECUTED 0010dc54 <_Protected_heap_Allocate_aligned>: void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ) { 10dc54: 55 push %ebp <== NOT EXECUTED 10dc55: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc57: 53 push %ebx <== NOT EXECUTED 10dc58: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED void *p; _RTEMS_Lock_allocator(); 10dc5b: ff 35 14 4f 12 00 pushl 0x124f14 <== NOT EXECUTED 10dc61: e8 be e9 ff ff call 10c624 <_API_Mutex_Lock> <== NOT EXECUTED p = _Heap_Allocate_aligned( the_heap, size, alignment ); 10dc66: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10dc69: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dc6c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dc6f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10dc72: e8 49 f0 ff ff call 10ccc0 <_Heap_Allocate_aligned> <== NOT EXECUTED 10dc77: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10dc79: 58 pop %eax <== NOT EXECUTED 10dc7a: ff 35 14 4f 12 00 pushl 0x124f14 <== NOT EXECUTED 10dc80: e8 e7 e9 ff ff call 10c66c <_API_Mutex_Unlock> <== NOT EXECUTED return p; } 10dc85: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10dc87: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10dc8a: c9 leave <== NOT EXECUTED 10dc8b: c3 ret <== NOT EXECUTED 0010dcc0 <_Protected_heap_Extend>: bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ) { 10dcc0: 55 push %ebp <== NOT EXECUTED 10dcc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dcc3: 53 push %ebx <== NOT EXECUTED 10dcc4: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 10dcc7: ff 35 14 4f 12 00 pushl 0x124f14 <== NOT EXECUTED 10dccd: e8 52 e9 ff ff call 10c624 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 10dcd2: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10dcd5: 50 push %eax <== NOT EXECUTED 10dcd6: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dcd9: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dcdc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10dcdf: e8 f0 3d 00 00 call 111ad4 <_Heap_Extend> <== NOT EXECUTED 10dce4: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10dce6: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10dce9: ff 35 14 4f 12 00 pushl 0x124f14 <== NOT EXECUTED 10dcef: e8 78 e9 ff ff call 10c66c <_API_Mutex_Unlock> <== NOT EXECUTED 10dcf4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dcf7: 85 db test %ebx,%ebx <== NOT EXECUTED 10dcf9: 0f 94 c0 sete %al <== NOT EXECUTED return (status == HEAP_EXTEND_SUCCESSFUL); } 10dcfc: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10dcff: c9 leave <== NOT EXECUTED 10dd00: c3 ret <== NOT EXECUTED 0010bdf0 <_Protected_heap_Free>: bool _Protected_heap_Free( Heap_Control *the_heap, void *start_address ) { 10bdf0: 55 push %ebp <== NOT EXECUTED 10bdf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bdf3: 53 push %ebx <== NOT EXECUTED 10bdf4: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED bool status; _RTEMS_Lock_allocator(); 10bdf7: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10bdfd: e8 66 ef ff ff call 10ad68 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 10be02: 5a pop %edx <== NOT EXECUTED 10be03: 59 pop %ecx <== NOT EXECUTED 10be04: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10be07: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10be0a: e8 c1 3b 00 00 call 10f9d0 <_Heap_Free> <== NOT EXECUTED 10be0f: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10be11: 58 pop %eax <== NOT EXECUTED 10be12: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10be18: e8 93 ef ff ff call 10adb0 <_API_Mutex_Unlock> <== NOT EXECUTED return status; } 10be1d: 88 d8 mov %bl,%al <== NOT EXECUTED 10be1f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10be22: c9 leave <== NOT EXECUTED 10be23: c3 ret <== NOT EXECUTED 001174a8 <_Protected_heap_Get_block_size>: bool _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ) { 1174a8: 55 push %ebp <== NOT EXECUTED 1174a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1174ab: 53 push %ebx <== NOT EXECUTED 1174ac: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED bool status; _RTEMS_Lock_allocator(); 1174af: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 1174b5: e8 ae 38 ff ff call 10ad68 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 1174ba: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1174bd: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1174c0: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1174c3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1174c6: e8 49 02 00 00 call 117714 <_Heap_Size_of_user_area> <== NOT EXECUTED 1174cb: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 1174cd: 58 pop %eax <== NOT EXECUTED 1174ce: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 1174d4: e8 d7 38 ff ff call 10adb0 <_API_Mutex_Unlock> <== NOT EXECUTED return status; } 1174d9: 88 d8 mov %bl,%al <== NOT EXECUTED 1174db: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1174de: c9 leave <== NOT EXECUTED 1174df: c3 ret <== NOT EXECUTED 001111d8 <_Protected_heap_Get_free_information>: bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 1111d8: 55 push %ebp <== NOT EXECUTED 1111d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1111db: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED /* * TBD: _Heap_Get_free_information does not error check or return status. */ _RTEMS_Lock_allocator(); 1111de: ff 35 b4 1f 16 00 pushl 0x161fb4 <== NOT EXECUTED 1111e4: e8 1f eb ff ff call 10fd08 <_API_Mutex_Lock> <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 1111e9: 5a pop %edx <== NOT EXECUTED 1111ea: 59 pop %ecx <== NOT EXECUTED 1111eb: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1111ee: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1111f1: e8 3e 5e 01 00 call 127034 <_Heap_Get_free_information> <== NOT EXECUTED _RTEMS_Unlock_allocator(); 1111f6: 58 pop %eax <== NOT EXECUTED 1111f7: ff 35 b4 1f 16 00 pushl 0x161fb4 <== NOT EXECUTED 1111fd: e8 4e eb ff ff call 10fd50 <_API_Mutex_Unlock> <== NOT EXECUTED return true; } 111202: b0 01 mov $0x1,%al <== NOT EXECUTED 111204: c9 leave <== NOT EXECUTED 111205: c3 ret <== NOT EXECUTED 0012731c <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 12731c: 55 push %ebp <== NOT EXECUTED 12731d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12731f: 56 push %esi <== NOT EXECUTED 127320: 53 push %ebx <== NOT EXECUTED 127321: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 127324: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Heap_Get_information_status status; if ( !the_heap ) 127327: 85 f6 test %esi,%esi <== NOT EXECUTED 127329: 74 39 je 127364 <_Protected_heap_Get_information+0x48> <== NOT EXECUTED return false; if ( !the_info ) 12732b: 85 db test %ebx,%ebx <== NOT EXECUTED 12732d: 74 35 je 127364 <_Protected_heap_Get_information+0x48> <== NOT EXECUTED return false; _RTEMS_Lock_allocator(); 12732f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 127332: ff 35 b4 1f 16 00 pushl 0x161fb4 <== NOT EXECUTED 127338: e8 cb 89 fe ff call 10fd08 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Get_information( the_heap, the_info ); 12733d: 5a pop %edx <== NOT EXECUTED 12733e: 59 pop %ecx <== NOT EXECUTED 12733f: 53 push %ebx <== NOT EXECUTED 127340: 56 push %esi <== NOT EXECUTED 127341: e8 3e 8e 00 00 call 130184 <_Heap_Get_information> <== NOT EXECUTED 127346: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 127348: 58 pop %eax <== NOT EXECUTED 127349: ff 35 b4 1f 16 00 pushl 0x161fb4 <== NOT EXECUTED 12734f: e8 fc 89 fe ff call 10fd50 <_API_Mutex_Unlock> <== NOT EXECUTED if ( status == HEAP_GET_INFORMATION_SUCCESSFUL ) 127354: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 127357: 85 db test %ebx,%ebx <== NOT EXECUTED 127359: 0f 94 c0 sete %al <== NOT EXECUTED return true; return false; } 12735c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12735f: 5b pop %ebx <== NOT EXECUTED 127360: 5e pop %esi <== NOT EXECUTED 127361: c9 leave <== NOT EXECUTED 127362: c3 ret <== NOT EXECUTED 127363: 90 nop <== NOT EXECUTED _RTEMS_Lock_allocator(); status = _Heap_Get_information( the_heap, the_info ); _RTEMS_Unlock_allocator(); if ( status == HEAP_GET_INFORMATION_SUCCESSFUL ) 127364: 31 c0 xor %eax,%eax <== NOT EXECUTED return true; return false; } 127366: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 127369: 5b pop %ebx <== NOT EXECUTED 12736a: 5e pop %esi <== NOT EXECUTED 12736b: c9 leave <== NOT EXECUTED 12736c: c3 ret <== NOT EXECUTED 001174e0 <_Protected_heap_Resize_block>: bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ) { 1174e0: 55 push %ebp <== NOT EXECUTED 1174e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1174e3: 53 push %ebx <== NOT EXECUTED 1174e4: 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(); 1174e7: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 1174ed: e8 76 38 ff ff call 10ad68 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Resize_block( 1174f2: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1174f5: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1174f8: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1174fb: 50 push %eax <== NOT EXECUTED 1174fc: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1174ff: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 117502: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 117505: e8 1e 00 00 00 call 117528 <_Heap_Resize_block> <== NOT EXECUTED 11750a: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_heap, starting_address, size, &old_mem_size, &avail_mem_size ); _RTEMS_Unlock_allocator(); 11750c: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 11750f: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 117515: e8 96 38 ff ff call 10adb0 <_API_Mutex_Unlock> <== NOT EXECUTED 11751a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11751d: 85 db test %ebx,%ebx <== NOT EXECUTED 11751f: 0f 94 c0 sete %al <== NOT EXECUTED return (status == HEAP_RESIZE_SUCCESSFUL); } 117522: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 117525: c9 leave <== NOT EXECUTED 117526: c3 ret <== NOT EXECUTED 0010de3c <_Protected_heap_Walk>: bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 10de3c: 55 push %ebp <== NOT EXECUTED 10de3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10de3f: 57 push %edi <== NOT EXECUTED 10de40: 56 push %esi <== NOT EXECUTED 10de41: 53 push %ebx <== NOT EXECUTED 10de42: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10de45: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10de48: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10de4b: 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 ) { 10de4e: a1 58 4e 12 00 mov 0x124e58,%eax <== NOT EXECUTED 10de53: 85 c0 test %eax,%eax <== NOT EXECUTED 10de55: 74 19 je 10de70 <_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 ); 10de57: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10de5a: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 10de5d: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10de60: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED } return status; } 10de63: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10de66: 5b pop %ebx <== NOT EXECUTED 10de67: 5e pop %esi <== NOT EXECUTED 10de68: 5f pop %edi <== NOT EXECUTED 10de69: 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 ); 10de6a: e9 49 3e 00 00 jmp 111cb8 <_Heap_Walk> <== NOT EXECUTED 10de6f: 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(); 10de70: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10de73: ff 35 14 4f 12 00 pushl 0x124f14 <== NOT EXECUTED 10de79: e8 a6 e7 ff ff call 10c624 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Walk( the_heap, source, do_dump ); 10de7e: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10de81: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10de84: 50 push %eax <== NOT EXECUTED 10de85: 56 push %esi <== NOT EXECUTED 10de86: 57 push %edi <== NOT EXECUTED 10de87: e8 2c 3e 00 00 call 111cb8 <_Heap_Walk> <== NOT EXECUTED 10de8c: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10de8e: 58 pop %eax <== NOT EXECUTED 10de8f: ff 35 14 4f 12 00 pushl 0x124f14 <== NOT EXECUTED 10de95: e8 d2 e7 ff ff call 10c66c <_API_Mutex_Unlock> <== NOT EXECUTED 10de9a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { status = _Heap_Walk( the_heap, source, do_dump ); } return status; } 10de9d: 88 d8 mov %bl,%al <== NOT EXECUTED 10de9f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dea2: 5b pop %ebx <== NOT EXECUTED 10dea3: 5e pop %esi <== NOT EXECUTED 10dea4: 5f pop %edi <== NOT EXECUTED 10dea5: c9 leave <== NOT EXECUTED 10dea6: c3 ret <== NOT EXECUTED 0010abb0 <_RTEMS_API_Initialize>: */ void _RTEMS_API_Initialize( rtems_configuration_table *configuration_table ) { 10abb0: 55 push %ebp <== NOT EXECUTED 10abb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10abb3: 53 push %ebx <== NOT EXECUTED 10abb4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED rtems_api_configuration_table *api_configuration; api_configuration = configuration_table->RTEMS_api_configuration; 10abb7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10abba: 8b 58 40 mov 0x40(%eax),%ebx <== NOT EXECUTED _Objects_Information_table[OBJECTS_CLASSIC_API] = _RTEMS_Objects; 10abbd: c7 05 94 f7 11 00 60 movl $0x11fd60,0x11f794 <== NOT EXECUTED 10abc4: fd 11 00 <== NOT EXECUTED _Attributes_Handler_initialization(); _Interrupt_Manager_initialization(); 10abc7: e8 1c 47 00 00 call 10f2e8 <_Interrupt_Manager_initialization> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) _Multiprocessing_Manager_initialization(); #endif _RTEMS_tasks_Manager_initialization( api_configuration->maximum_tasks ); 10abcc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10abcf: ff 33 pushl (%ebx) <== NOT EXECUTED 10abd1: e8 8a 48 00 00 call 10f460 <_RTEMS_tasks_Manager_initialization> <== NOT EXECUTED _Timer_Manager_initialization( api_configuration->maximum_timers ); 10abd6: 58 pop %eax <== NOT EXECUTED 10abd7: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10abda: e8 ad 47 00 00 call 10f38c <_Timer_Manager_initialization> <== NOT EXECUTED _Signal_Manager_initialization(); 10abdf: e8 04 48 00 00 call 10f3e8 <_Signal_Manager_initialization> <== NOT EXECUTED _Event_Manager_initialization(); 10abe4: e8 ef 46 00 00 call 10f2d8 <_Event_Manager_initialization> <== NOT EXECUTED _Message_queue_Manager_initialization( 10abe9: 58 pop %eax <== NOT EXECUTED 10abea: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10abed: e8 fe 46 00 00 call 10f2f0 <_Message_queue_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_message_queues ); _Semaphore_Manager_initialization( api_configuration->maximum_semaphores ); 10abf2: 58 pop %eax <== NOT EXECUTED 10abf3: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 10abf6: e8 c9 47 00 00 call 10f3c4 <_Semaphore_Manager_initialization> <== NOT EXECUTED _Partition_Manager_initialization( api_configuration->maximum_partitions ); 10abfb: 58 pop %eax <== NOT EXECUTED 10abfc: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 10abff: e8 14 47 00 00 call 10f318 <_Partition_Manager_initialization> <== NOT EXECUTED _Region_Manager_initialization( api_configuration->maximum_regions ); 10ac04: 59 pop %ecx <== NOT EXECUTED 10ac05: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10ac08: e8 57 47 00 00 call 10f364 <_Region_Manager_initialization> <== NOT EXECUTED _Dual_ported_memory_Manager_initialization( api_configuration->maximum_ports); 10ac0d: 5a pop %edx <== NOT EXECUTED 10ac0e: ff 73 1c pushl 0x1c(%ebx) <== NOT EXECUTED 10ac11: e8 9e 46 00 00 call 10f2b4 <_Dual_ported_memory_Manager_initialization> <== NOT EXECUTED _Rate_monotonic_Manager_initialization( api_configuration->maximum_periods ); 10ac16: 58 pop %eax <== NOT EXECUTED 10ac17: ff 73 20 pushl 0x20(%ebx) <== NOT EXECUTED 10ac1a: e8 1d 47 00 00 call 10f33c <_Rate_monotonic_Manager_initialization> <== NOT EXECUTED _Barrier_Manager_initialization( api_configuration->maximum_barriers ); 10ac1f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac22: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 10ac25: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10ac28: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ac2b: 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 ); 10ac2c: e9 5f 46 00 00 jmp 10f290 <_Barrier_Manager_initialization> <== NOT EXECUTED 0010f5f4 <_RTEMS_Tasks_Invoke_task_variable_dtor>: void _RTEMS_Tasks_Invoke_task_variable_dtor( Thread_Control *the_thread, rtems_task_variable_t *tvp ) { 10f5f4: 55 push %ebp <== NOT EXECUTED 10f5f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f5f7: 56 push %esi <== NOT EXECUTED 10f5f8: 53 push %ebx <== NOT EXECUTED 10f5f9: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED void (*dtor)(void *); void *value; dtor = tvp->dtor; 10f5fc: 8b 4b 10 mov 0x10(%ebx),%ecx <== NOT EXECUTED if (_Thread_Is_executing(the_thread)) { 10f5ff: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10f602: 3b 05 7c f8 11 00 cmp 0x11f87c,%eax <== NOT EXECUTED 10f608: 74 1e je 10f628 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x34> <== NOT EXECUTED value = *tvp->ptr; *tvp->ptr = tvp->gval; } else { value = tvp->tval; 10f60a: 8b 73 0c mov 0xc(%ebx),%esi <== NOT EXECUTED } if ( dtor ) 10f60d: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f60f: 74 09 je 10f61a <_RTEMS_Tasks_Invoke_task_variable_dtor+0x26> <== NOT EXECUTED (*dtor)(value); 10f611: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f614: 56 push %esi <== NOT EXECUTED 10f615: ff d1 call *%ecx <== NOT EXECUTED 10f617: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Workspace_Free(tvp); 10f61a: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 10f61d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f620: 5b pop %ebx <== NOT EXECUTED 10f621: 5e pop %esi <== NOT EXECUTED 10f622: c9 leave <== NOT EXECUTED } if ( dtor ) (*dtor)(value); _Workspace_Free(tvp); 10f623: e9 40 de ff ff jmp 10d468 <_Workspace_Free> <== NOT EXECUTED void (*dtor)(void *); void *value; dtor = tvp->dtor; if (_Thread_Is_executing(the_thread)) { value = *tvp->ptr; 10f628: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 10f62b: 8b 32 mov (%edx),%esi <== NOT EXECUTED *tvp->ptr = tvp->gval; 10f62d: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10f630: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10f632: eb d9 jmp 10f60d <_RTEMS_Tasks_Invoke_task_variable_dtor+0x19> <== NOT EXECUTED 0010f558 <_RTEMS_tasks_Create_extension>: bool _RTEMS_tasks_Create_extension( Thread_Control *executing, Thread_Control *created ) { 10f558: 55 push %ebp <== NOT EXECUTED 10f559: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f55b: 53 push %ebx <== NOT EXECUTED 10f55c: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10f55f: 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() ) 10f562: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10f567: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10f56a: 80 78 04 01 cmpb $0x1,0x4(%eax) <== NOT EXECUTED 10f56e: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10f570: 83 e0 c0 and $0xffffffc0,%eax <== NOT EXECUTED 10f573: 83 c0 60 add $0x60,%eax <== NOT EXECUTED to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); 10f576: 50 push %eax <== NOT EXECUTED 10f577: e8 04 df ff ff call 10d480 <_Workspace_Allocate> <== NOT EXECUTED 10f57c: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !api ) 10f57e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f581: 85 c0 test %eax,%eax <== NOT EXECUTED 10f583: 74 67 je 10f5ec <_RTEMS_tasks_Create_extension+0x94> <== NOT EXECUTED return false; created->API_Extensions[ THREAD_API_RTEMS ] = api; 10f585: 89 83 f4 00 00 00 mov %eax,0xf4(%ebx) <== NOT EXECUTED api->pending_events = EVENT_SETS_NONE_PENDING; 10f58b: 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 10f591: 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 10f595: 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. 10f59c: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) <== NOT EXECUTED * 10f5a3: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10f5aa: 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 10f5b1: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) <== NOT EXECUTED _ASR_Initialize( &api->Signal ); created->task_variables = NULL; 10f5b8: c7 83 04 01 00 00 00 movl $0x0,0x104(%ebx) <== NOT EXECUTED 10f5bf: 00 00 00 <== NOT EXECUTED if ( rtems_configuration_get_notepads_enabled() ) { 10f5c2: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10f5c7: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10f5ca: 80 78 04 00 cmpb $0x0,0x4(%eax) <== NOT EXECUTED 10f5ce: 74 12 je 10f5e2 <_RTEMS_tasks_Create_extension+0x8a> <== NOT EXECUTED 10f5d0: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f5d2: 66 90 xchg %ax,%ax <== NOT EXECUTED for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; 10f5d4: c7 44 82 20 00 00 00 movl $0x0,0x20(%edx,%eax,4) <== NOT EXECUTED 10f5db: 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++) 10f5dc: 40 inc %eax <== NOT EXECUTED 10f5dd: 83 f8 10 cmp $0x10,%eax <== NOT EXECUTED 10f5e0: 75 f2 jne 10f5d4 <_RTEMS_tasks_Create_extension+0x7c> <== NOT EXECUTED 10f5e2: b0 01 mov $0x1,%al <== NOT EXECUTED api->Notepads[i] = 0; } return true; } 10f5e4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f5e7: c9 leave <== NOT EXECUTED 10f5e8: c3 ret <== NOT EXECUTED 10f5e9: 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 ) 10f5ec: 31 c0 xor %eax,%eax <== NOT EXECUTED for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; } return true; } 10f5ee: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f5f1: c9 leave <== NOT EXECUTED 10f5f2: c3 ret <== NOT EXECUTED 0010f504 <_RTEMS_tasks_Delete_extension>: User_extensions_routine _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 10f504: 55 push %ebp <== NOT EXECUTED 10f505: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f507: 56 push %esi <== NOT EXECUTED 10f508: 53 push %ebx <== NOT EXECUTED 10f509: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Free per task variable memory */ tvp = deleted->task_variables; 10f50c: 8b 86 04 01 00 00 mov 0x104(%esi),%eax <== NOT EXECUTED deleted->task_variables = NULL; 10f512: c7 86 04 01 00 00 00 movl $0x0,0x104(%esi) <== NOT EXECUTED 10f519: 00 00 00 <== NOT EXECUTED while (tvp) { 10f51c: 85 c0 test %eax,%eax <== NOT EXECUTED 10f51e: 74 15 je 10f535 <_RTEMS_tasks_Delete_extension+0x31> <== NOT EXECUTED next = (rtems_task_variable_t *)tvp->next; 10f520: 8b 18 mov (%eax),%ebx <== NOT EXECUTED _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); 10f522: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f525: 50 push %eax <== NOT EXECUTED 10f526: 56 push %esi <== NOT EXECUTED 10f527: e8 c8 00 00 00 call 10f5f4 <_RTEMS_Tasks_Invoke_task_variable_dtor> <== NOT EXECUTED 10f52c: 89 d8 mov %ebx,%eax <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 10f52e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f531: 85 db test %ebx,%ebx <== NOT EXECUTED 10f533: 75 eb jne 10f520 <_RTEMS_tasks_Delete_extension+0x1c> <== NOT EXECUTED /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); 10f535: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f538: ff b6 f4 00 00 00 pushl 0xf4(%esi) <== NOT EXECUTED 10f53e: e8 25 df ff ff call 10d468 <_Workspace_Free> <== NOT EXECUTED deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 10f543: c7 86 f4 00 00 00 00 movl $0x0,0xf4(%esi) <== NOT EXECUTED 10f54a: 00 00 00 <== NOT EXECUTED 10f54d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10f550: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f553: 5b pop %ebx <== NOT EXECUTED 10f554: 5e pop %esi <== NOT EXECUTED 10f555: c9 leave <== NOT EXECUTED 10f556: c3 ret <== NOT EXECUTED 0010f44c <_RTEMS_tasks_Initialize_user_tasks>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks( void ) { 10f44c: 55 push %ebp <== NOT EXECUTED 10f44d: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( _RTEMS_tasks_Initialize_user_tasks_p ) 10f44f: 8b 0d 2c b2 11 00 mov 0x11b22c,%ecx <== NOT EXECUTED 10f455: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f457: 74 03 je 10f45c <_RTEMS_tasks_Initialize_user_tasks+0x10> <== NOT EXECUTED (*_RTEMS_tasks_Initialize_user_tasks_p)(); } 10f459: c9 leave <== NOT EXECUTED */ void _RTEMS_tasks_Initialize_user_tasks( void ) { if ( _RTEMS_tasks_Initialize_user_tasks_p ) (*_RTEMS_tasks_Initialize_user_tasks_p)(); 10f45a: ff e1 jmp *%ecx <== NOT EXECUTED } 10f45c: c9 leave <== NOT EXECUTED 10f45d: 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 54 f8 11 00 mov 0x11f854,%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 9d 0d 00 00 call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED 0010f460 <_RTEMS_tasks_Manager_initialization>: */ void _RTEMS_tasks_Manager_initialization( uint32_t maximum_tasks ) { 10f460: 55 push %ebp <== NOT EXECUTED 10f461: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f463: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f466: 6a 04 push $0x4 <== NOT EXECUTED 10f468: 6a 00 push $0x0 <== NOT EXECUTED 10f46a: 68 08 01 00 00 push $0x108 <== NOT EXECUTED 10f46f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f472: 6a 01 push $0x1 <== NOT EXECUTED 10f474: 6a 02 push $0x2 <== NOT EXECUTED 10f476: 68 40 f7 11 00 push $0x11f740 <== NOT EXECUTED 10f47b: e8 ec c6 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED /* * Add all the extensions for this API */ _User_extensions_Add_API_set( &_RTEMS_tasks_User_extensions ); 10f480: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10f483: 68 00 d6 11 00 push $0x11d600 <== NOT EXECUTED 10f488: e8 d7 0a 00 00 call 10ff64 <_User_extensions_Add_API_set> <== NOT EXECUTED _API_extensions_Add( &_RTEMS_tasks_API_extensions ); 10f48d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f490: c7 45 08 e0 d5 11 00 movl $0x11d5e0,0x8(%ebp) <== NOT EXECUTED MP_PACKET_TASKS, _RTEMS_tasks_MP_Process_packet ); #endif } 10f497: 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 ); 10f498: e9 57 b8 ff ff jmp 10acf4 <_API_extensions_Add> <== NOT EXECUTED 0010f4a0 <_RTEMS_tasks_Post_switch_extension>: */ void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) { 10f4a0: 55 push %ebp <== NOT EXECUTED 10f4a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f4a3: 57 push %edi <== NOT EXECUTED 10f4a4: 56 push %esi <== NOT EXECUTED 10f4a5: 53 push %ebx <== NOT EXECUTED 10f4a6: 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 ]; 10f4a9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10f4ac: 8b b0 f4 00 00 00 mov 0xf4(%eax),%esi <== NOT EXECUTED if ( !api ) 10f4b2: 85 f6 test %esi,%esi <== NOT EXECUTED 10f4b4: 74 45 je 10f4fb <_RTEMS_tasks_Post_switch_extension+0x5b> <== NOT EXECUTED * Signal Processing */ asr = &api->Signal; _ISR_Disable( level ); 10f4b6: 9c pushf <== NOT EXECUTED 10f4b7: fa cli <== NOT EXECUTED 10f4b8: 58 pop %eax <== NOT EXECUTED signal_set = asr->signals_posted; 10f4b9: 8b 7e 14 mov 0x14(%esi),%edi <== NOT EXECUTED asr->signals_posted = 0; 10f4bc: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED _ISR_Enable( level ); 10f4c3: 50 push %eax <== NOT EXECUTED 10f4c4: 9d popf <== NOT EXECUTED if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 10f4c5: 85 ff test %edi,%edi <== NOT EXECUTED 10f4c7: 74 32 je 10f4fb <_RTEMS_tasks_Post_switch_extension+0x5b> <== NOT EXECUTED return; asr->nest_level += 1; 10f4c9: ff 46 1c incl 0x1c(%esi) <== NOT EXECUTED rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10f4cc: 50 push %eax <== NOT EXECUTED 10f4cd: 8d 5d f0 lea -0x10(%ebp),%ebx <== NOT EXECUTED 10f4d0: 53 push %ebx <== NOT EXECUTED 10f4d1: 68 ff ff 00 00 push $0xffff <== NOT EXECUTED 10f4d6: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 10f4d9: e8 ae 12 00 00 call 11078c <== NOT EXECUTED (*asr->handler)( signal_set ); 10f4de: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10f4e1: ff 56 0c call *0xc(%esi) <== NOT EXECUTED asr->nest_level -= 1; 10f4e4: ff 4e 1c decl 0x1c(%esi) <== NOT EXECUTED rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10f4e7: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10f4ea: 53 push %ebx <== NOT EXECUTED 10f4eb: 68 ff ff 00 00 push $0xffff <== NOT EXECUTED 10f4f0: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10f4f3: e8 94 12 00 00 call 11078c <== NOT EXECUTED 10f4f8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10f4fb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f4fe: 5b pop %ebx <== NOT EXECUTED 10f4ff: 5e pop %esi <== NOT EXECUTED 10f500: 5f pop %edi <== NOT EXECUTED 10f501: c9 leave <== NOT EXECUTED 10f502: c3 ret <== NOT EXECUTED 0010f3f0 <_RTEMS_tasks_Start_extension>: User_extensions_routine _RTEMS_tasks_Start_extension( Thread_Control *executing, Thread_Control *started ) { 10f3f0: 55 push %ebp <== NOT EXECUTED 10f3f1: 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; 10f3f3: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f3f6: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10f3fc: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED } 10f402: c9 leave <== NOT EXECUTED 10f403: c3 ret <== NOT EXECUTED 0010f404 <_RTEMS_tasks_Switch_extension>: void _RTEMS_tasks_Switch_extension( Thread_Control *executing, Thread_Control *heir ) { 10f404: 55 push %ebp <== NOT EXECUTED 10f405: 89 e5 mov %esp,%ebp <== NOT EXECUTED /* * Per Task Variables */ tvp = executing->task_variables; 10f407: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10f40a: 8b 88 04 01 00 00 mov 0x104(%eax),%ecx <== NOT EXECUTED while (tvp) { 10f410: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f412: 74 13 je 10f427 <_RTEMS_tasks_Switch_extension+0x23> <== NOT EXECUTED tvp->tval = *tvp->ptr; 10f414: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10f417: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10f419: 89 51 0c mov %edx,0xc(%ecx) <== NOT EXECUTED *tvp->ptr = tvp->gval; 10f41c: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED 10f41f: 89 10 mov %edx,(%eax) <== NOT EXECUTED tvp = (rtems_task_variable_t *)tvp->next; 10f421: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED /* * Per Task Variables */ tvp = executing->task_variables; while (tvp) { 10f423: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f425: 75 ed jne 10f414 <_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; 10f427: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f42a: 8b 88 04 01 00 00 mov 0x104(%eax),%ecx <== NOT EXECUTED while (tvp) { 10f430: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f432: 74 13 je 10f447 <_RTEMS_tasks_Switch_extension+0x43> <== NOT EXECUTED tvp->gval = *tvp->ptr; 10f434: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10f437: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10f439: 89 51 08 mov %edx,0x8(%ecx) <== NOT EXECUTED *tvp->ptr = tvp->tval; 10f43c: 8b 51 0c mov 0xc(%ecx),%edx <== NOT EXECUTED 10f43f: 89 10 mov %edx,(%eax) <== NOT EXECUTED tvp = (rtems_task_variable_t *)tvp->next; 10f441: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { 10f443: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f445: 75 ed jne 10f434 <_RTEMS_tasks_Switch_extension+0x30> <== NOT EXECUTED tvp->gval = *tvp->ptr; *tvp->ptr = tvp->tval; tvp = (rtems_task_variable_t *)tvp->next; } } 10f447: c9 leave <== NOT EXECUTED 10f448: 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 10 1a 00 00 call 10cad4 <_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 1c 40 12 00 cmp 0x12401c,%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 24 40 12 00 push $0x124024 <== NOT EXECUTED 10b103: e8 a8 39 00 00 call 10eab0 <_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 a8 38 00 00 call 10e9bc <_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 0010f33c <_Rate_monotonic_Manager_initialization>: */ void _Rate_monotonic_Manager_initialization( uint32_t maximum_periods ) { 10f33c: 55 push %ebp <== NOT EXECUTED 10f33d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f33f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f342: 6a 04 push $0x4 <== NOT EXECUTED 10f344: 6a 00 push $0x0 <== NOT EXECUTED 10f346: 68 8c 00 00 00 push $0x8c <== NOT EXECUTED 10f34b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f34e: 6a 08 push $0x8 <== NOT EXECUTED 10f350: 6a 02 push $0x2 <== NOT EXECUTED 10f352: 68 00 03 12 00 push $0x120300 <== NOT EXECUTED 10f357: e8 10 c8 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10f35c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10f35f: c9 leave <== NOT EXECUTED 10f360: 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 60 3e 12 00 push $0x123e60 <== NOT EXECUTED 10b6f3: e8 48 1d 00 00 call 10d440 <_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 58 3f 12 00 mov 0x123f58,%eax <== NOT EXECUTED 10b71f: 48 dec %eax <== NOT EXECUTED 10b720: a3 58 3f 12 00 mov %eax,0x123f58 <== 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 9a 21 00 00 call 10d8dc <_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 3c 40 12 00 push $0x12403c <== NOT EXECUTED 10b769: e8 ea 35 00 00 call 10ed58 <_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 a3 19 00 00 call 10cad4 <_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 60 39 00 00 call 10eab0 <_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 1c 40 12 00 mov 0x12401c,%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 24 40 12 00 push $0x124024 <== NOT EXECUTED 10b174: e8 37 39 00 00 call 10eab0 <_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 37 38 00 00 call 10e9bc <_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 fb 38 00 00 call 10ea8c <_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 04 39 00 00 call 10eab0 <_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 01 38 00 00 call 10e9bc <_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 c2 38 00 00 call 10ea8c <_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 7b 38 00 00 call 10ea68 <_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 a9 37 00 00 call 10e9bc <_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 6a 38 00 00 call 10ea8c <_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 23 38 00 00 call 10ea68 <_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 0010f364 <_Region_Manager_initialization>: */ void _Region_Manager_initialization( uint32_t maximum_regions ) { 10f364: 55 push %ebp <== NOT EXECUTED 10f365: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f367: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f36a: 6a 04 push $0x4 <== NOT EXECUTED 10f36c: 6a 00 push $0x0 <== NOT EXECUTED 10f36e: 68 c0 00 00 00 push $0xc0 <== NOT EXECUTED 10f373: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f376: 6a 06 push $0x6 <== NOT EXECUTED 10f378: 6a 02 push $0x2 <== NOT EXECUTED 10f37a: 68 40 03 12 00 push $0x120340 <== NOT EXECUTED 10f37f: e8 e8 c7 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10f384: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_REGION, 0 /* XXX _Region_MP_Process_packet */ ); #endif } 10f387: c9 leave <== NOT EXECUTED 10f388: c3 ret <== NOT EXECUTED 0011a928 <_Region_Process_queue>: */ void _Region_Process_queue( Region_Control *the_region ) { 11a928: 55 push %ebp <== NOT EXECUTED 11a929: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11a92b: 57 push %edi <== NOT EXECUTED 11a92c: 56 push %esi <== NOT EXECUTED 11a92d: 53 push %ebx <== NOT EXECUTED 11a92e: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 11a931: 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 11a934: a1 78 6d 13 00 mov 0x136d78,%eax <== NOT EXECUTED 11a939: 40 inc %eax <== NOT EXECUTED 11a93a: a3 78 6d 13 00 mov %eax,0x136d78 <== 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(); 11a93f: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 11a945: e8 8e ab ff ff call 1154d8 <_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 ); 11a94a: 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. * 11a94d: 8d 46 68 lea 0x68(%esi),%eax <== NOT EXECUTED 11a950: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 11a953: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11a956: eb 33 jmp 11a98b <_Region_Process_queue+0x63> <== NOT EXECUTED 11a958: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11a95b: ff 70 24 pushl 0x24(%eax) <== NOT EXECUTED 11a95e: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 11a961: e8 66 b5 ff ff call 115ecc <_Heap_Allocate> <== NOT EXECUTED 11a966: 89 c2 mov %eax,%edx <== NOT EXECUTED the_segment = (void **) _Region_Allocate_segment( the_region, the_thread->Wait.count ); if ( the_segment == NULL ) 11a968: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11a96b: 85 c0 test %eax,%eax <== NOT EXECUTED 11a96d: 74 2e je 11a99d <_Region_Process_queue+0x75> <== NOT EXECUTED break; *(void **)the_thread->Wait.return_argument = the_segment; 11a96f: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 11a972: 89 10 mov %edx,(%eax) <== NOT EXECUTED the_region->number_of_used_blocks += 1; 11a974: ff 46 64 incl 0x64(%esi) <== NOT EXECUTED _Thread_queue_Extract( &the_region->Wait_queue, the_thread ); 11a977: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11a97a: 53 push %ebx <== NOT EXECUTED 11a97b: 57 push %edi <== NOT EXECUTED 11a97c: e8 47 06 00 00 call 11afc8 <_Thread_queue_Extract> <== NOT EXECUTED the_thread->Wait.return_code = RTEMS_SUCCESSFUL; 11a981: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED 11a988: 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 ); 11a98b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11a98e: 57 push %edi <== NOT EXECUTED 11a98f: e8 28 07 00 00 call 11b0bc <_Thread_queue_First> <== NOT EXECUTED 11a994: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( the_thread == NULL ) 11a996: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11a999: 85 c0 test %eax,%eax <== NOT EXECUTED 11a99b: 75 bb jne 11a958 <_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(); } 11a99d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11a9a0: 5b pop %ebx <== NOT EXECUTED 11a9a1: 5e pop %esi <== NOT EXECUTED 11a9a2: 5f pop %edi <== NOT EXECUTED 11a9a3: 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(); 11a9a4: e9 db ca ff ff jmp 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 0010f3c4 <_Semaphore_Manager_initialization>: */ void _Semaphore_Manager_initialization( uint32_t maximum_semaphores ) { 10f3c4: 55 push %ebp <== NOT EXECUTED 10f3c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f3c7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f3ca: 6a 04 push $0x4 <== NOT EXECUTED 10f3cc: 6a 00 push $0x0 <== NOT EXECUTED 10f3ce: 6a 78 push $0x78 <== NOT EXECUTED 10f3d0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f3d3: 6a 03 push $0x3 <== NOT EXECUTED 10f3d5: 6a 02 push $0x2 <== NOT EXECUTED 10f3d7: 68 00 f7 11 00 push $0x11f700 <== NOT EXECUTED 10f3dc: e8 8b c7 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10f3e1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_SEMAPHORE, _Semaphore_MP_Process_packet ); #endif } 10f3e4: c9 leave <== NOT EXECUTED 10f3e5: 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 fc 8f 11 00 mov 0x118ffc(,%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 18 90 11 00 mov 0x119018(,%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 0010f3e8 <_Signal_Manager_initialization>: * * Output parameters: NONE */ void _Signal_Manager_initialization( void ) { 10f3e8: 55 push %ebp <== NOT EXECUTED 10f3e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED _MPCI_Register_packet_processor( MP_PACKET_SIGNAL, _Signal_MP_Process_packet ); #endif } 10f3eb: c9 leave <== NOT EXECUTED 10f3ec: c3 ret <== NOT EXECUTED 0010b29c <_TOD_Get>: */ void _TOD_Get( struct timespec *time ) { 10b29c: 55 push %ebp <== NOT EXECUTED 10b29d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b29f: 56 push %esi <== NOT EXECUTED 10b2a0: 53 push %ebx <== NOT EXECUTED 10b2a1: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10b2a4: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED ISR_Level level; struct timespec offset; /* assume time checked by caller */ offset.tv_sec = 0; 10b2a7: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED offset.tv_nsec = 0; 10b2ae: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED /* _TOD_Now is a proper POSIX time */ _ISR_Disable( level ); 10b2b5: 9c pushf <== NOT EXECUTED 10b2b6: fa cli <== NOT EXECUTED 10b2b7: 5b pop %ebx <== NOT EXECUTED *time = _TOD_Now; 10b2b8: a1 4c f8 11 00 mov 0x11f84c,%eax <== NOT EXECUTED 10b2bd: 8b 15 50 f8 11 00 mov 0x11f850,%edx <== NOT EXECUTED 10b2c3: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10b2c5: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED if ( _Watchdog_Nanoseconds_since_tick_handler ) 10b2c8: a1 88 f9 11 00 mov 0x11f988,%eax <== NOT EXECUTED 10b2cd: 85 c0 test %eax,%eax <== NOT EXECUTED 10b2cf: 74 05 je 10b2d6 <_TOD_Get+0x3a> <== NOT EXECUTED offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)(); 10b2d1: ff d0 call *%eax <== NOT EXECUTED 10b2d3: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED _ISR_Enable( level ); 10b2d6: 53 push %ebx <== NOT EXECUTED 10b2d7: 9d popf <== NOT EXECUTED _Timespec_Add_to( time, &offset ); 10b2d8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b2db: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b2de: 50 push %eax <== NOT EXECUTED 10b2df: 56 push %esi <== NOT EXECUTED 10b2e0: e8 97 1c 00 00 call 10cf7c <_Timespec_Add_to> <== NOT EXECUTED 10b2e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b2e8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b2eb: 5b pop %ebx <== NOT EXECUTED 10b2ec: 5e pop %esi <== NOT EXECUTED 10b2ed: c9 leave <== NOT EXECUTED 10b2ee: c3 ret <== NOT EXECUTED 0010f8e8 <_TOD_Get_uptime>: */ void _TOD_Get_uptime( struct timespec *uptime ) { 10f8e8: 55 push %ebp <== NOT EXECUTED 10f8e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f8eb: 56 push %esi <== NOT EXECUTED 10f8ec: 53 push %ebx <== NOT EXECUTED 10f8ed: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10f8f0: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED ISR_Level level; struct timespec offset; /* assume uptime checked by caller */ offset.tv_sec = 0; 10f8f3: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED offset.tv_nsec = 0; 10f8fa: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED _ISR_Disable( level ); 10f901: 9c pushf <== NOT EXECUTED 10f902: fa cli <== NOT EXECUTED 10f903: 5b pop %ebx <== NOT EXECUTED *uptime = _TOD_Uptime; 10f904: a1 38 f8 11 00 mov 0x11f838,%eax <== NOT EXECUTED 10f909: 8b 15 3c f8 11 00 mov 0x11f83c,%edx <== NOT EXECUTED 10f90f: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10f911: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED if ( _Watchdog_Nanoseconds_since_tick_handler ) 10f914: a1 88 f9 11 00 mov 0x11f988,%eax <== NOT EXECUTED 10f919: 85 c0 test %eax,%eax <== NOT EXECUTED 10f91b: 74 05 je 10f922 <_TOD_Get_uptime+0x3a> <== NOT EXECUTED offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)(); 10f91d: ff d0 call *%eax <== NOT EXECUTED 10f91f: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED _ISR_Enable( level ); 10f922: 53 push %ebx <== NOT EXECUTED 10f923: 9d popf <== NOT EXECUTED _Timespec_Add_to( uptime, &offset ); 10f924: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f927: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10f92a: 50 push %eax <== NOT EXECUTED 10f92b: 56 push %esi <== NOT EXECUTED 10f92c: e8 4b d6 ff ff call 10cf7c <_Timespec_Add_to> <== NOT EXECUTED 10f931: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10f934: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f937: 5b pop %ebx <== NOT EXECUTED 10f938: 5e pop %esi <== NOT EXECUTED 10f939: c9 leave <== NOT EXECUTED 10f93a: c3 ret <== NOT EXECUTED 0010b2f0 <_TOD_Handler_initialization>: */ void _TOD_Handler_initialization( uint32_t microseconds_per_tick ) { 10b2f0: 55 push %ebp <== NOT EXECUTED 10b2f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED _TOD_Microseconds_per_tick = microseconds_per_tick; 10b2f3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b2f6: a3 80 f9 11 00 mov %eax,0x11f980 <== NOT EXECUTED /* POSIX format TOD (timespec) */ _TOD_Now.tv_sec = TOD_SECONDS_1970_THROUGH_1988; 10b2fb: c7 05 4c f8 11 00 00 movl $0x21dae500,0x11f84c <== NOT EXECUTED 10b302: e5 da 21 <== NOT EXECUTED _TOD_Now.tv_nsec = 0; 10b305: c7 05 50 f8 11 00 00 movl $0x0,0x11f850 <== NOT EXECUTED 10b30c: 00 00 00 <== NOT EXECUTED /* Uptime (timespec) */ _TOD_Uptime.tv_sec = 0; 10b30f: c7 05 38 f8 11 00 00 movl $0x0,0x11f838 <== NOT EXECUTED 10b316: 00 00 00 <== NOT EXECUTED _TOD_Uptime.tv_nsec = 0; 10b319: c7 05 3c f8 11 00 00 movl $0x0,0x11f83c <== NOT EXECUTED 10b320: 00 00 00 <== NOT EXECUTED /* TOD has not been set */ _TOD_Is_set = FALSE; 10b323: c6 05 cc f7 11 00 00 movb $0x0,0x11f7cc <== NOT EXECUTED _TOD_Activate(); } 10b32a: c9 leave <== NOT EXECUTED 10b32b: c3 ret <== NOT EXECUTED 0010c62c <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 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 /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10c636: a1 d8 b7 12 00 mov 0x12b7d8,%eax <== NOT EXECUTED 10c63b: 40 inc %eax <== NOT EXECUTED 10c63c: a3 d8 b7 12 00 mov %eax,0x12b7d8 <== NOT EXECUTED _Thread_Disable_dispatch(); _TOD_Deactivate(); if ( time->tv_sec < _TOD_Seconds_since_epoch ) 10c641: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10c643: a1 6c b8 12 00 mov 0x12b86c,%eax <== NOT EXECUTED 10c648: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10c64a: 7c 34 jl 10c680 <_TOD_Set+0x54> <== NOT EXECUTED */ bool _Protected_heap_Free( Heap_Control *the_heap, void *start_address ); 10c64c: 51 push %ecx <== NOT EXECUTED 10c64d: 29 c2 sub %eax,%edx <== NOT EXECUTED 10c64f: 52 push %edx <== NOT EXECUTED 10c650: 6a 00 push $0x0 <== NOT EXECUTED 10c652: 68 b0 b8 12 00 push $0x12b8b0 <== NOT EXECUTED 10c657: e8 a8 23 00 00 call 10ea04 <_Watchdog_Adjust> <== NOT EXECUTED 10c65c: 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; 10c65f: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10c661: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10c664: a3 70 b8 12 00 mov %eax,0x12b870 <== NOT EXECUTED 10c669: 89 15 6c b8 12 00 mov %edx,0x12b86c <== NOT EXECUTED _TOD_Is_set = TRUE; 10c66f: c6 05 ec b7 12 00 01 movb $0x1,0x12b7ec <== NOT EXECUTED _TOD_Activate(); _Thread_Enable_dispatch(); } 10c676: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c679: c9 leave <== NOT EXECUTED _TOD_Now = *time; _TOD_Is_set = TRUE; _TOD_Activate(); _Thread_Enable_dispatch(); 10c67a: e9 99 11 00 00 jmp 10d818 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c67f: 90 nop <== NOT EXECUTED 10c680: 51 push %ecx <== NOT EXECUTED 10c681: 29 d0 sub %edx,%eax <== NOT EXECUTED 10c683: 50 push %eax <== NOT EXECUTED 10c684: 6a 01 push $0x1 <== NOT EXECUTED 10c686: 68 b0 b8 12 00 push $0x12b8b0 <== NOT EXECUTED 10c68b: e8 74 23 00 00 call 10ea04 <_Watchdog_Adjust> <== NOT EXECUTED 10c690: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c693: eb ca jmp 10c65f <_TOD_Set+0x33> <== NOT EXECUTED 0010b32c <_TOD_Tickle_ticks>: * * Output parameters: NONE */ void _TOD_Tickle_ticks( void ) { 10b32c: 55 push %ebp <== NOT EXECUTED 10b32d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b32f: 53 push %ebx <== NOT EXECUTED 10b330: 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; 10b333: a1 80 f9 11 00 mov 0x11f980,%eax <== NOT EXECUTED 10b338: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10b33b: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10b33e: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10b341: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED 10b344: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED tick.tv_sec = 0; 10b347: 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; 10b34e: a1 24 f9 11 00 mov 0x11f924,%eax <== NOT EXECUTED 10b353: 40 inc %eax <== NOT EXECUTED 10b354: a3 24 f9 11 00 mov %eax,0x11f924 <== NOT EXECUTED /* Update the timespec format uptime */ (void) _Timespec_Add_to( &_TOD_Uptime, &tick ); 10b359: 8d 5d f4 lea -0xc(%ebp),%ebx <== NOT EXECUTED 10b35c: 53 push %ebx <== NOT EXECUTED 10b35d: 68 38 f8 11 00 push $0x11f838 <== NOT EXECUTED 10b362: e8 15 1c 00 00 call 10cf7c <_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 ); 10b367: 58 pop %eax <== NOT EXECUTED 10b368: 5a pop %edx <== NOT EXECUTED 10b369: 53 push %ebx <== NOT EXECUTED 10b36a: 68 4c f8 11 00 push $0x11f84c <== NOT EXECUTED 10b36f: e8 08 1c 00 00 call 10cf7c <_Timespec_Add_to> <== NOT EXECUTED 10b374: 89 c3 mov %eax,%ebx <== NOT EXECUTED while ( seconds ) { 10b376: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b379: 85 c0 test %eax,%eax <== NOT EXECUTED 10b37b: 74 16 je 10b393 <_TOD_Tickle_ticks+0x67> <== NOT EXECUTED 10b37d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ); 10b380: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b383: 68 90 f8 11 00 push $0x11f890 <== NOT EXECUTED 10b388: e8 6b 20 00 00 call 10d3f8 <_Watchdog_Tickle> <== NOT EXECUTED 10b38d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b390: 4b dec %ebx <== NOT EXECUTED 10b391: 75 ed jne 10b380 <_TOD_Tickle_ticks+0x54> <== NOT EXECUTED _Watchdog_Tickle_seconds(); seconds--; } } 10b393: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b396: c9 leave <== NOT EXECUTED 10b397: 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 e0 c6 11 movzwl 0x11c6e0(%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 14 c7 11 movzwl 0x11c714(%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 fa c6 11 movzwl 0x11c6fa(%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 a0 b9 12 00 divl 0x12b9a0 <== 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 54 c7 11 00 mov 0x11c754(,%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 20 c7 11 00 mov 0x11c720(,%eax,4),%eax <== NOT EXECUTED 10ad21: eb e8 jmp 10ad0b <_TOD_Validate+0x5b> <== NOT EXECUTED 0010be70 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10be70: 55 push %ebp <== NOT EXECUTED 10be71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10be73: 57 push %edi <== NOT EXECUTED 10be74: 56 push %esi <== NOT EXECUTED 10be75: 53 push %ebx <== NOT EXECUTED 10be76: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10be79: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10be7c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10be7f: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 10be82: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED */ /* * Save original state */ original_state = the_thread->current_state; 10be85: 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 ); 10be88: 53 push %ebx <== NOT EXECUTED 10be89: e8 4a 0e 00 00 call 10ccd8 <_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 ) 10be8e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10be91: 39 73 14 cmp %esi,0x14(%ebx) <== NOT EXECUTED 10be94: 74 0d je 10bea3 <_Thread_Change_priority+0x33> <== NOT EXECUTED _Thread_Set_priority( the_thread, new_priority ); 10be96: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10be99: 56 push %esi <== NOT EXECUTED 10be9a: 53 push %ebx <== NOT EXECUTED 10be9b: e8 f4 0c 00 00 call 10cb94 <_Thread_Set_priority> <== NOT EXECUTED 10bea0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _ISR_Disable( level ); 10bea3: 9c pushf <== NOT EXECUTED 10bea4: fa cli <== NOT EXECUTED 10bea5: 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; 10bea6: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED if ( state != STATES_TRANSIENT ) { 10bea9: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10beac: 74 3a je 10bee8 <_Thread_Change_priority+0x78> <== NOT EXECUTED /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10beae: 83 e7 04 and $0x4,%edi <== NOT EXECUTED 10beb1: 75 08 jne 10bebb <_Thread_Change_priority+0x4b> <== NOT EXECUTED the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10beb3: 89 d0 mov %edx,%eax <== NOT EXECUTED 10beb5: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 10beb8: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10bebb: 56 push %esi <== NOT EXECUTED 10bebc: 9d popf <== NOT EXECUTED if ( _States_Is_waiting_on_thread_queue( state ) ) { 10bebd: 81 e2 e0 be 03 00 and $0x3bee0,%edx <== NOT EXECUTED 10bec3: 75 0b jne 10bed0 <_Thread_Change_priority+0x60> <== NOT EXECUTED if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10bec5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bec8: 5b pop %ebx <== NOT EXECUTED 10bec9: 5e pop %esi <== NOT EXECUTED 10beca: 5f pop %edi <== NOT EXECUTED 10becb: c9 leave <== NOT EXECUTED 10becc: c3 ret <== NOT EXECUTED 10becd: 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 ); 10bed0: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 10bed3: 8b 43 44 mov 0x44(%ebx),%eax <== NOT EXECUTED 10bed6: 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 ); } 10bed9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bedc: 5b pop %ebx <== NOT EXECUTED 10bedd: 5e pop %esi <== NOT EXECUTED 10bede: 5f pop %edi <== NOT EXECUTED 10bedf: 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 ); 10bee0: e9 1b 0c 00 00 jmp 10cb00 <_Thread_queue_Requeue> <== NOT EXECUTED 10bee5: 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 ) ) { 10bee8: 83 e7 04 and $0x4,%edi <== NOT EXECUTED 10beeb: 75 41 jne 10bf2e <_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 ); 10beed: 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 10bef4: 8b 93 90 00 00 00 mov 0x90(%ebx),%edx <== NOT EXECUTED 10befa: 66 8b 83 96 00 00 00 mov 0x96(%ebx),%ax <== NOT EXECUTED 10bf01: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10bf04: 66 a1 70 f8 11 00 mov 0x11f870,%ax <== NOT EXECUTED 10bf0a: 0b 83 94 00 00 00 or 0x94(%ebx),%eax <== NOT EXECUTED 10bf10: 66 a3 70 f8 11 00 mov %ax,0x11f870 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); if ( prepend_it ) 10bf16: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10bf1a: 74 70 je 10bf8c <_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 10bf1c: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax <== NOT EXECUTED 10bf22: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED 10bf25: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10bf27: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10bf29: 89 13 mov %edx,(%ebx) <== NOT EXECUTED 10bf2b: 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 ); 10bf2e: 56 push %esi <== NOT EXECUTED 10bf2f: 9d popf <== NOT EXECUTED 10bf30: fa cli <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10bf31: 66 8b 0d 70 f8 11 00 mov 0x11f870,%cx <== NOT EXECUTED 10bf38: 31 d2 xor %edx,%edx <== NOT EXECUTED 10bf3a: 89 d0 mov %edx,%eax <== NOT EXECUTED 10bf3c: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10bf40: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10bf43: 66 8b 8c 00 00 f9 11 mov 0x11f900(%eax,%eax,1),%cx <== NOT EXECUTED 10bf4a: 00 <== NOT EXECUTED 10bf4b: 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. 10bf4f: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10bf52: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10bf55: 01 d0 add %edx,%eax <== NOT EXECUTED 10bf57: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10bf5a: 8b 15 80 f7 11 00 mov 0x11f780,%edx <== NOT EXECUTED 10bf60: 8b 04 82 mov (%edx,%eax,4),%eax <== NOT EXECUTED 10bf63: a3 48 f8 11 00 mov %eax,0x11f848 <== NOT EXECUTED void *starting_address, size_t size ); /** * This function attempts to allocate a block of @a size bytes from 10bf68: 8b 15 7c f8 11 00 mov 0x11f87c,%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() && 10bf6e: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10bf70: 74 0d je 10bf7f <_Thread_Change_priority+0x10f> <== NOT EXECUTED 10bf72: 80 7a 76 00 cmpb $0x0,0x76(%edx) <== NOT EXECUTED 10bf76: 74 07 je 10bf7f <_Thread_Change_priority+0x10f> <== NOT EXECUTED _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; 10bf78: c6 05 8c f8 11 00 01 movb $0x1,0x11f88c <== NOT EXECUTED _ISR_Enable( level ); 10bf7f: 56 push %esi <== NOT EXECUTED 10bf80: 9d popf <== NOT EXECUTED } 10bf81: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bf84: 5b pop %ebx <== NOT EXECUTED 10bf85: 5e pop %esi <== NOT EXECUTED 10bf86: 5f pop %edi <== NOT EXECUTED 10bf87: c9 leave <== NOT EXECUTED 10bf88: c3 ret <== NOT EXECUTED 10bf89: 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 ); 10bf8c: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax <== NOT EXECUTED 10bf92: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10bf95: 89 13 mov %edx,(%ebx) <== NOT EXECUTED 10bf97: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10bf9a: 89 58 08 mov %ebx,0x8(%eax) <== NOT EXECUTED 10bf9d: 89 1a mov %ebx,(%edx) <== NOT EXECUTED 10bf9f: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED 10bfa2: eb 8a jmp 10bf2e <_Thread_Change_priority+0xbe> <== NOT EXECUTED 0010bfa4 <_Thread_Clear_state>: void _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) { 10bfa4: 55 push %ebp <== NOT EXECUTED 10bfa5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bfa7: 53 push %ebx <== NOT EXECUTED 10bfa8: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10bfab: 9c pushf <== NOT EXECUTED 10bfac: fa cli <== NOT EXECUTED 10bfad: 5b pop %ebx <== NOT EXECUTED current_state = the_thread->current_state; 10bfae: 8b 51 10 mov 0x10(%ecx),%edx <== NOT EXECUTED if ( current_state & state ) { 10bfb1: 85 55 0c test %edx,0xc(%ebp) <== NOT EXECUTED 10bfb4: 74 72 je 10c028 <_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( 10bfb6: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10bfb9: f7 d0 not %eax <== NOT EXECUTED 10bfbb: 21 d0 and %edx,%eax <== NOT EXECUTED current_state = 10bfbd: 89 41 10 mov %eax,0x10(%ecx) <== NOT EXECUTED the_thread->current_state = _States_Clear( state, current_state ); if ( _States_Is_ready( current_state ) ) { 10bfc0: 85 c0 test %eax,%eax <== NOT EXECUTED 10bfc2: 75 64 jne 10c028 <_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 10bfc4: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10bfca: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10bfd1: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10bfd4: 66 a1 70 f8 11 00 mov 0x11f870,%ax <== NOT EXECUTED 10bfda: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10bfe0: 66 a3 70 f8 11 00 mov %ax,0x11f870 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10bfe6: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10bfec: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10bfef: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10bff1: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10bff4: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10bff7: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10bff9: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10bffc: 53 push %ebx <== NOT EXECUTED 10bffd: 9d popf <== NOT EXECUTED 10bffe: 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 ) { 10bfff: 8b 51 14 mov 0x14(%ecx),%edx <== NOT EXECUTED 10c002: a1 48 f8 11 00 mov 0x11f848,%eax <== NOT EXECUTED 10c007: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10c00a: 73 1c jae 10c028 <_Thread_Clear_state+0x84> <== NOT EXECUTED _Thread_Heir = the_thread; 10c00c: 89 0d 48 f8 11 00 mov %ecx,0x11f848 <== NOT EXECUTED if ( _Thread_Executing->is_preemptible || 10c012: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED 10c017: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10c01b: 75 04 jne 10c021 <_Thread_Clear_state+0x7d> <== NOT EXECUTED 10c01d: 85 d2 test %edx,%edx <== NOT EXECUTED 10c01f: 75 07 jne 10c028 <_Thread_Clear_state+0x84> <== NOT EXECUTED the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 10c021: c6 05 8c f8 11 00 01 movb $0x1,0x11f88c <== NOT EXECUTED } } } _ISR_Enable( level ); 10c028: 53 push %ebx <== NOT EXECUTED 10c029: 9d popf <== NOT EXECUTED } 10c02a: 5b pop %ebx <== NOT EXECUTED 10c02b: c9 leave <== NOT EXECUTED 10c02c: c3 ret <== NOT EXECUTED 0010c030 <_Thread_Close>: void _Thread_Close( Objects_Information *information, Thread_Control *the_thread ) { 10c030: 55 push %ebp <== NOT EXECUTED 10c031: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c033: 56 push %esi <== NOT EXECUTED 10c034: 53 push %ebx <== NOT EXECUTED 10c035: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10c038: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10c03b: 0f b7 56 08 movzwl 0x8(%esi),%edx <== NOT EXECUTED 10c03f: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10c042: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) <== NOT EXECUTED 10c049: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10c04e: 48 dec %eax <== NOT EXECUTED 10c04f: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED * disappear and set a transient state on it. So we temporarily * unnest dispatching. */ _Thread_Unnest_dispatch(); _User_extensions_Thread_delete( the_thread ); 10c054: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c057: 56 push %esi <== NOT EXECUTED 10c058: e8 3f 11 00 00 call 10d19c <_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 10c05d: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10c062: 40 inc %eax <== NOT EXECUTED 10c063: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== 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 ); 10c068: 59 pop %ecx <== NOT EXECUTED 10c069: 58 pop %eax <== NOT EXECUTED 10c06a: 56 push %esi <== NOT EXECUTED 10c06b: 53 push %ebx <== NOT EXECUTED 10c06c: e8 23 f6 ff ff call 10b694 <_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 ); 10c071: 58 pop %eax <== NOT EXECUTED 10c072: 5a pop %edx <== NOT EXECUTED 10c073: 6a 01 push $0x1 <== NOT EXECUTED 10c075: 56 push %esi <== NOT EXECUTED 10c076: e8 85 0b 00 00 call 10cc00 <_Thread_Set_state> <== NOT EXECUTED if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 10c07b: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10c07e: e8 a5 09 00 00 call 10ca28 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 10c083: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c086: 84 c0 test %al,%al <== NOT EXECUTED 10c088: 75 06 jne 10c090 <_Thread_Close+0x60> <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 10c08a: 83 7e 50 02 cmpl $0x2,0x50(%esi) <== NOT EXECUTED 10c08e: 74 68 je 10c0f8 <_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 ) ) 10c090: 3b 35 40 f8 11 00 cmp 0x11f840,%esi <== NOT EXECUTED 10c096: 74 74 je 10c10c <_Thread_Close+0xdc> <== NOT EXECUTED _Thread_Deallocate_fp(); #endif the_thread->fp_context = NULL; 10c098: c7 86 ec 00 00 00 00 movl $0x0,0xec(%esi) <== NOT EXECUTED 10c09f: 00 00 00 <== NOT EXECUTED if ( the_thread->Start.fp_context ) 10c0a2: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED 10c0a8: 85 c0 test %eax,%eax <== NOT EXECUTED 10c0aa: 74 0c je 10c0b8 <_Thread_Close+0x88> <== NOT EXECUTED (void) _Workspace_Free( the_thread->Start.fp_context ); 10c0ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c0af: 50 push %eax <== NOT EXECUTED 10c0b0: e8 b3 13 00 00 call 10d468 <_Workspace_Free> <== NOT EXECUTED 10c0b5: 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 ); 10c0b8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c0bb: 56 push %esi <== NOT EXECUTED 10c0bc: e8 ef 0c 00 00 call 10cdb0 <_Thread_Stack_Free> <== NOT EXECUTED the_thread->Start.stack = NULL; 10c0c1: c7 86 d0 00 00 00 00 movl $0x0,0xd0(%esi) <== NOT EXECUTED 10c0c8: 00 00 00 <== NOT EXECUTED if ( the_thread->extensions ) 10c0cb: 8b 86 00 01 00 00 mov 0x100(%esi),%eax <== NOT EXECUTED 10c0d1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c0d4: 85 c0 test %eax,%eax <== NOT EXECUTED 10c0d6: 74 0c je 10c0e4 <_Thread_Close+0xb4> <== NOT EXECUTED (void) _Workspace_Free( the_thread->extensions ); 10c0d8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c0db: 50 push %eax <== NOT EXECUTED 10c0dc: e8 87 13 00 00 call 10d468 <_Workspace_Free> <== NOT EXECUTED 10c0e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_thread->extensions = NULL; 10c0e4: c7 86 00 01 00 00 00 movl $0x0,0x100(%esi) <== NOT EXECUTED 10c0eb: 00 00 00 <== NOT EXECUTED } 10c0ee: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c0f1: 5b pop %ebx <== NOT EXECUTED 10c0f2: 5e pop %esi <== NOT EXECUTED 10c0f3: c9 leave <== NOT EXECUTED 10c0f4: c3 ret <== NOT EXECUTED 10c0f5: 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 ); 10c0f8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c0fb: 8d 46 48 lea 0x48(%esi),%eax <== NOT EXECUTED 10c0fe: 50 push %eax <== NOT EXECUTED 10c0ff: e8 88 12 00 00 call 10d38c <_Watchdog_Remove> <== NOT EXECUTED 10c104: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c107: eb 87 jmp 10c090 <_Thread_Close+0x60> <== NOT EXECUTED 10c109: 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( 10c10c: c7 05 40 f8 11 00 00 movl $0x0,0x11f840 <== NOT EXECUTED 10c113: 00 00 00 <== NOT EXECUTED 10c116: eb 80 jmp 10c098 <_Thread_Close+0x68> <== NOT EXECUTED 0010c118 <_Thread_Create_idle>: * * _Thread_Create_idle */ void _Thread_Create_idle( void ) { 10c118: 55 push %ebp <== NOT EXECUTED 10c119: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c11b: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10c11e: 68 40 f9 11 00 push $0x11f940 <== NOT EXECUTED 10c123: e8 ec f4 ff ff call 10b614 <_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(); 10c128: a3 8c f9 11 00 mov %eax,0x11f98c <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10c12d: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10c132: 40 inc %eax <== NOT EXECUTED 10c133: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED * that when _Thread_Initialize unnests dispatch that we do not * do anything stupid. */ _Thread_Disable_dispatch(); _Thread_Initialize( 10c138: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10c13d: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED 10c140: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c143: 68 f8 90 11 00 push $0x1190f8 <== NOT EXECUTED 10c148: 6a 00 push $0x0 <== NOT EXECUTED 10c14a: 6a 00 push $0x0 <== NOT EXECUTED 10c14c: 6a 00 push $0x0 <== NOT EXECUTED 10c14e: 6a 01 push $0x1 <== NOT EXECUTED 10c150: 0f b6 05 d4 b1 11 00 movzbl 0x11b1d4,%eax <== NOT EXECUTED 10c157: 50 push %eax <== NOT EXECUTED 10c158: 6a 00 push $0x0 <== NOT EXECUTED 10c15a: a1 d0 b1 11 00 mov 0x11b1d0,%eax <== NOT EXECUTED 10c15f: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10c161: 73 02 jae 10c165 <_Thread_Create_idle+0x4d> <== NOT EXECUTED 10c163: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c165: 50 push %eax <== NOT EXECUTED 10c166: 6a 00 push $0x0 <== NOT EXECUTED 10c168: ff 35 8c f9 11 00 pushl 0x11f98c <== NOT EXECUTED 10c16e: 68 40 f9 11 00 push $0x11f940 <== NOT EXECUTED 10c173: e8 78 02 00 00 call 10c3f0 <_Thread_Initialize> <== NOT EXECUTED 10c178: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10c17d: 48 dec %eax <== NOT EXECUTED 10c17e: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 10c183: 8b 15 8c f9 11 00 mov 0x11f98c,%edx <== NOT EXECUTED 10c189: 89 15 7c f8 11 00 mov %edx,0x11f87c <== NOT EXECUTED 10c18f: 89 15 48 f8 11 00 mov %edx,0x11f848 <== NOT EXECUTED _Thread_Executing = _Thread_Idle; _Thread_Start( 10c195: 83 c4 24 add $0x24,%esp <== NOT EXECUTED 10c198: 6a 00 push $0x0 <== NOT EXECUTED 10c19a: 6a 00 push $0x0 <== NOT EXECUTED 10c19c: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10c1a1: ff 70 14 pushl 0x14(%eax) <== NOT EXECUTED 10c1a4: 6a 00 push $0x0 <== NOT EXECUTED 10c1a6: 52 push %edx <== NOT EXECUTED 10c1a7: e8 9c 0c 00 00 call 10ce48 <_Thread_Start> <== NOT EXECUTED 10c1ac: 83 c4 20 add $0x20,%esp <== NOT EXECUTED _Configuration_Table->idle_task, NULL, 0 ); } 10c1af: c9 leave <== NOT EXECUTED 10c1b0: c3 ret <== NOT EXECUTED 0010c1b4 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 10c1b4: 55 push %ebp <== NOT EXECUTED 10c1b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c1b7: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10c1ba: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10c1bd: 50 push %eax <== NOT EXECUTED 10c1be: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c1c1: e8 aa 01 00 00 call 10c370 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10c1c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c1c9: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10c1cc: 85 d2 test %edx,%edx <== NOT EXECUTED 10c1ce: 75 1c jne 10c1ec <_Thread_Delay_ended+0x38> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10c1d0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c1d3: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10c1d8: 50 push %eax <== NOT EXECUTED 10c1d9: e8 c6 fd ff ff call 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 10c1de: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10c1e3: 48 dec %eax <== NOT EXECUTED 10c1e4: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED 10c1e9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_LOCAL: _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; } } 10c1ec: c9 leave <== NOT EXECUTED 10c1ed: c3 ret <== NOT EXECUTED 0010c1f0 <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10c1f0: 55 push %ebp <== NOT EXECUTED 10c1f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c1f3: 57 push %edi <== NOT EXECUTED 10c1f4: 56 push %esi <== NOT EXECUTED 10c1f5: 53 push %ebx <== NOT EXECUTED 10c1f6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10c1f9: 8b 35 7c f8 11 00 mov 0x11f87c,%esi <== NOT EXECUTED _ISR_Disable( level ); 10c1ff: 9c pushf <== NOT EXECUTED 10c200: fa cli <== NOT EXECUTED 10c201: 5a pop %edx <== NOT EXECUTED while ( _Context_Switch_necessary == TRUE ) { 10c202: a0 8c f8 11 00 mov 0x11f88c,%al <== NOT EXECUTED 10c207: 84 c0 test %al,%al <== NOT EXECUTED 10c209: 0f 84 11 01 00 00 je 10c320 <_Thread_Dispatch+0x130> <== NOT EXECUTED 10c20f: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 10c212: e9 d2 00 00 00 jmp 10c2e9 <_Thread_Dispatch+0xf9> <== NOT EXECUTED 10c217: 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 ); 10c218: 52 push %edx <== NOT EXECUTED 10c219: 9d popf <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec uptime, ran; _TOD_Get_uptime( &uptime ); 10c21a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c21d: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10c220: 50 push %eax <== NOT EXECUTED 10c221: e8 c2 36 00 00 call 10f8e8 <_TOD_Get_uptime> <== NOT EXECUTED _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); 10c226: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c229: 57 push %edi <== NOT EXECUTED 10c22a: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10c22d: 50 push %eax <== NOT EXECUTED 10c22e: 68 84 f8 11 00 push $0x11f884 <== NOT EXECUTED 10c233: e8 7c 0d 00 00 call 10cfb4 <_Timespec_Subtract> <== NOT EXECUTED _Timespec_Add_to( &executing->cpu_time_used, &ran ); 10c238: 58 pop %eax <== NOT EXECUTED 10c239: 5a pop %edx <== NOT EXECUTED 10c23a: 57 push %edi <== NOT EXECUTED 10c23b: 8d 86 84 00 00 00 lea 0x84(%esi),%eax <== NOT EXECUTED 10c241: 50 push %eax <== NOT EXECUTED 10c242: e8 35 0d 00 00 call 10cf7c <_Timespec_Add_to> <== NOT EXECUTED _Thread_Time_of_last_context_switch = uptime; 10c247: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10c24a: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10c24d: a3 84 f8 11 00 mov %eax,0x11f884 <== NOT EXECUTED 10c252: 89 15 88 f8 11 00 mov %edx,0x11f888 <== NOT EXECUTED #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10c258: 8b 15 44 f8 11 00 mov 0x11f844,%edx <== NOT EXECUTED 10c25e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c261: 85 d2 test %edx,%edx <== NOT EXECUTED 10c263: 74 10 je 10c275 <_Thread_Dispatch+0x85> <== NOT EXECUTED executing->libc_reent = *_Thread_libc_reent; 10c265: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10c267: 89 86 f0 00 00 00 mov %eax,0xf0(%esi) <== NOT EXECUTED *_Thread_libc_reent = heir->libc_reent; 10c26d: 8b 83 f0 00 00 00 mov 0xf0(%ebx),%eax <== NOT EXECUTED 10c273: 89 02 mov %eax,(%edx) <== NOT EXECUTED } _User_extensions_Thread_switch( executing, heir ); 10c275: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c278: 53 push %ebx <== NOT EXECUTED 10c279: 56 push %esi <== NOT EXECUTED 10c27a: e8 9d 0f 00 00 call 10d21c <_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 ); 10c27f: 59 pop %ecx <== NOT EXECUTED 10c280: 58 pop %eax <== NOT EXECUTED 10c281: 8d 83 d4 00 00 00 lea 0xd4(%ebx),%eax <== NOT EXECUTED 10c287: 50 push %eax <== NOT EXECUTED 10c288: 8d 86 d4 00 00 00 lea 0xd4(%esi),%eax <== NOT EXECUTED 10c28e: 50 push %eax <== NOT EXECUTED 10c28f: e8 8c 12 00 00 call 10d520 <_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) && 10c294: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c297: 8b 96 ec 00 00 00 mov 0xec(%esi),%edx <== NOT EXECUTED 10c29d: 85 d2 test %edx,%edx <== NOT EXECUTED 10c29f: 74 36 je 10c2d7 <_Thread_Dispatch+0xe7> <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10c2a1: a1 40 f8 11 00 mov 0x11f840,%eax <== NOT EXECUTED 10c2a6: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10c2a8: 74 2d je 10c2d7 <_Thread_Dispatch+0xe7> <== NOT EXECUTED !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10c2aa: 85 c0 test %eax,%eax <== NOT EXECUTED 10c2ac: 74 11 je 10c2bf <_Thread_Dispatch+0xcf> <== NOT EXECUTED _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10c2ae: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c2b1: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10c2b6: 50 push %eax <== NOT EXECUTED 10c2b7: e8 98 12 00 00 call 10d554 <_CPU_Context_save_fp> <== NOT EXECUTED 10c2bc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Context_Restore_fp( &executing->fp_context ); 10c2bf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c2c2: 8d 86 ec 00 00 00 lea 0xec(%esi),%eax <== NOT EXECUTED 10c2c8: 50 push %eax <== NOT EXECUTED 10c2c9: e8 90 12 00 00 call 10d55e <_CPU_Context_restore_fp> <== NOT EXECUTED _Thread_Allocated_fp = executing; 10c2ce: 89 35 40 f8 11 00 mov %esi,0x11f840 <== NOT EXECUTED 10c2d4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10c2d7: 8b 35 7c f8 11 00 mov 0x11f87c,%esi <== NOT EXECUTED _ISR_Disable( level ); 10c2dd: 9c pushf <== NOT EXECUTED 10c2de: fa cli <== NOT EXECUTED 10c2df: 5a pop %edx <== NOT EXECUTED Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Context_Switch_necessary == TRUE ) { 10c2e0: a0 8c f8 11 00 mov 0x11f88c,%al <== NOT EXECUTED 10c2e5: 84 c0 test %al,%al <== NOT EXECUTED 10c2e7: 74 37 je 10c320 <_Thread_Dispatch+0x130> <== NOT EXECUTED heir = _Thread_Heir; 10c2e9: 8b 1d 48 f8 11 00 mov 0x11f848,%ebx <== NOT EXECUTED _Thread_Dispatch_disable_level = 1; 10c2ef: c7 05 b8 f7 11 00 01 movl $0x1,0x11f7b8 <== NOT EXECUTED 10c2f6: 00 00 00 <== NOT EXECUTED _Context_Switch_necessary = FALSE; 10c2f9: c6 05 8c f8 11 00 00 movb $0x0,0x11f88c <== NOT EXECUTED _Thread_Executing = heir; 10c300: 89 1d 7c f8 11 00 mov %ebx,0x11f87c <== 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 ) 10c306: 83 7b 7c 01 cmpl $0x1,0x7c(%ebx) <== NOT EXECUTED 10c30a: 0f 85 08 ff ff ff jne 10c218 <_Thread_Dispatch+0x28> <== NOT EXECUTED heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c310: a1 84 f7 11 00 mov 0x11f784,%eax <== NOT EXECUTED 10c315: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10c318: e9 fb fe ff ff jmp 10c218 <_Thread_Dispatch+0x28> <== NOT EXECUTED 10c31d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED executing = _Thread_Executing; _ISR_Disable( level ); } _Thread_Dispatch_disable_level = 0; 10c320: c7 05 b8 f7 11 00 00 movl $0x0,0x11f7b8 <== NOT EXECUTED 10c327: 00 00 00 <== NOT EXECUTED _ISR_Enable( level ); 10c32a: 52 push %edx <== NOT EXECUTED 10c32b: 9d popf <== NOT EXECUTED if ( _Thread_Do_post_task_switch_extension || 10c32c: a1 60 f8 11 00 mov 0x11f860,%eax <== NOT EXECUTED 10c331: 85 c0 test %eax,%eax <== NOT EXECUTED 10c333: 75 06 jne 10c33b <_Thread_Dispatch+0x14b> <== NOT EXECUTED 10c335: 80 7e 75 00 cmpb $0x0,0x75(%esi) <== NOT EXECUTED 10c339: 74 09 je 10c344 <_Thread_Dispatch+0x154> <== NOT EXECUTED executing->do_post_task_switch_extension ) { executing->do_post_task_switch_extension = false; 10c33b: c6 46 75 00 movb $0x0,0x75(%esi) <== NOT EXECUTED _API_extensions_Run_postswitch(); 10c33f: e8 74 e9 ff ff call 10acb8 <_API_extensions_Run_postswitch> <== NOT EXECUTED } } 10c344: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c347: 5b pop %ebx <== NOT EXECUTED 10c348: 5e pop %esi <== NOT EXECUTED 10c349: 5f pop %edi <== NOT EXECUTED 10c34a: c9 leave <== NOT EXECUTED 10c34b: c3 ret <== NOT EXECUTED 0010c34c <_Thread_Enable_dispatch>: */ #if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \ (__RTEMS_DO_NOT_INLINE_THREAD_ENABLE_DISPATCH__ == 1) ) void _Thread_Enable_dispatch( void ) { 10c34c: 55 push %ebp <== NOT EXECUTED 10c34d: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( --_Thread_Dispatch_disable_level ) 10c34f: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10c354: 48 dec %eax <== NOT EXECUTED 10c355: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED 10c35a: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10c35f: 85 c0 test %eax,%eax <== NOT EXECUTED 10c361: 74 05 je 10c368 <_Thread_Enable_dispatch+0x1c> <== NOT EXECUTED return; _Thread_Dispatch(); } 10c363: c9 leave <== NOT EXECUTED 10c364: c3 ret <== NOT EXECUTED 10c365: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10c368: 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(); 10c369: e9 82 fe ff ff jmp 10c1f0 <_Thread_Dispatch> <== NOT EXECUTED 00110a24 <_Thread_Evaluate_mode>: * * XXX */ bool _Thread_Evaluate_mode( void ) { 110a24: 55 push %ebp <== NOT EXECUTED 110a25: 89 e5 mov %esp,%ebp <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 110a27: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED if ( !_States_Is_ready( executing->current_state ) || 110a2c: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 110a2f: 85 d2 test %edx,%edx <== NOT EXECUTED 110a31: 75 0e jne 110a41 <_Thread_Evaluate_mode+0x1d> <== NOT EXECUTED 110a33: 3b 05 48 f8 11 00 cmp 0x11f848,%eax <== NOT EXECUTED 110a39: 74 11 je 110a4c <_Thread_Evaluate_mode+0x28> <== NOT EXECUTED 110a3b: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 110a3f: 74 0b je 110a4c <_Thread_Evaluate_mode+0x28> <== NOT EXECUTED ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) { _Context_Switch_necessary = TRUE; 110a41: c6 05 8c f8 11 00 01 movb $0x1,0x11f88c <== NOT EXECUTED 110a48: b0 01 mov $0x1,%al <== NOT EXECUTED return TRUE; } return FALSE; } 110a4a: c9 leave <== NOT EXECUTED 110a4b: 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; 110a4c: 31 c0 xor %eax,%eax <== NOT EXECUTED } return FALSE; } 110a4e: c9 leave <== NOT EXECUTED 110a4f: c3 ret <== NOT EXECUTED 0010c370 <_Thread_Get>: Thread_Control *_Thread_Get ( Objects_Id id, Objects_Locations *location ) { 10c370: 55 push %ebp <== NOT EXECUTED 10c371: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c373: 53 push %ebx <== NOT EXECUTED 10c374: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10c377: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c37a: 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 ) ) { 10c37d: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10c37f: 74 4b je 10c3cc <_Thread_Get+0x5c> <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10c381: 89 ca mov %ecx,%edx <== NOT EXECUTED 10c383: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10c386: 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. 10c389: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10c38c: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10c38f: 77 2b ja 10c3bc <_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 :) */ 10c391: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10c393: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED 10c396: 48 dec %eax <== NOT EXECUTED 10c397: 75 23 jne 10c3bc <_Thread_Get+0x4c> <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } api_information = _Objects_Information_table[ the_api ]; 10c399: 8b 04 95 8c f7 11 00 mov 0x11f78c(,%edx,4),%eax <== NOT EXECUTED if ( !api_information ) { 10c3a0: 85 c0 test %eax,%eax <== NOT EXECUTED 10c3a2: 74 44 je 10c3e8 <_Thread_Get+0x78> <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = api_information[ the_class ]; 10c3a4: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED if ( !information ) { 10c3a7: 85 c0 test %eax,%eax <== NOT EXECUTED 10c3a9: 74 3d je 10c3e8 <_Thread_Get+0x78> <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 10c3ab: 52 push %edx <== NOT EXECUTED 10c3ac: 53 push %ebx <== NOT EXECUTED 10c3ad: 51 push %ecx <== NOT EXECUTED 10c3ae: 50 push %eax <== NOT EXECUTED 10c3af: e8 54 f7 ff ff call 10bb08 <_Objects_Get> <== NOT EXECUTED 10c3b4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED done: return tp; } 10c3b7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c3ba: c9 leave <== NOT EXECUTED 10c3bb: c3 ret <== NOT EXECUTED goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ *location = OBJECTS_ERROR; 10c3bc: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED 10c3c2: 31 c0 xor %eax,%eax <== NOT EXECUTED tp = (Thread_Control *) _Objects_Get( information, id, location ); done: return tp; } 10c3c4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c3c7: c9 leave <== NOT EXECUTED 10c3c8: c3 ret <== NOT EXECUTED 10c3c9: 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 10c3cc: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10c3d1: 40 inc %eax <== NOT EXECUTED 10c3d2: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== 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; 10c3d7: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED tp = _Thread_Executing; 10c3dd: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED tp = (Thread_Control *) _Objects_Get( information, id, location ); done: return tp; } 10c3e2: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c3e5: c9 leave <== NOT EXECUTED 10c3e6: c3 ret <== NOT EXECUTED 10c3e7: 90 nop <== NOT EXECUTED goto done; } information = api_information[ the_class ]; if ( !information ) { *location = OBJECTS_ERROR; 10c3e8: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED 10c3ee: eb d4 jmp 10c3c4 <_Thread_Get+0x54> <== NOT EXECUTED 00110a50 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 110a50: 55 push %ebp <== NOT EXECUTED 110a51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110a53: 53 push %ebx <== NOT EXECUTED 110a54: 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; 110a57: 8b 1d 7c f8 11 00 mov 0x11f87c,%ebx <== NOT EXECUTED /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 110a5d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED _ISR_Set_level(level); 110a63: 85 c0 test %eax,%eax <== NOT EXECUTED 110a65: 0f 84 91 00 00 00 je 110afc <_Thread_Handler+0xac> <== NOT EXECUTED 110a6b: fa cli <== NOT EXECUTED #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; 110a6c: a0 78 f5 11 00 mov 0x11f578,%al <== NOT EXECUTED 110a71: 88 45 fb mov %al,-0x5(%ebp) <== NOT EXECUTED doneConstructors = 1; 110a74: c6 05 78 f5 11 00 01 movb $0x1,0x11f578 <== 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 ) ) { 110a7b: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax <== NOT EXECUTED 110a81: 85 c0 test %eax,%eax <== NOT EXECUTED 110a83: 74 24 je 110aa9 <_Thread_Handler+0x59> <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 110a85: a1 40 f8 11 00 mov 0x11f840,%eax <== NOT EXECUTED 110a8a: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 110a8c: 74 1b je 110aa9 <_Thread_Handler+0x59> <== NOT EXECUTED if ( _Thread_Allocated_fp != NULL ) 110a8e: 85 c0 test %eax,%eax <== NOT EXECUTED 110a90: 74 11 je 110aa3 <_Thread_Handler+0x53> <== NOT EXECUTED _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 110a92: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110a95: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 110a9a: 50 push %eax <== NOT EXECUTED 110a9b: e8 b4 ca ff ff call 10d554 <_CPU_Context_save_fp> <== NOT EXECUTED 110aa0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Allocated_fp = executing; 110aa3: 89 1d 40 f8 11 00 mov %ebx,0x11f840 <== 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 ); 110aa9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110aac: 53 push %ebx <== NOT EXECUTED 110aad: e8 e2 c5 ff ff call 10d094 <_User_extensions_Thread_begin> <== NOT EXECUTED /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 110ab2: e8 95 b8 ff ff call 10c34c <_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) */ 110ab7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110aba: 80 7d fb 00 cmpb $0x0,-0x5(%ebp) <== NOT EXECUTED 110abe: 74 6c je 110b2c <_Thread_Handler+0xdc> <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 110ac0: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax <== NOT EXECUTED 110ac6: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 110ac9: 74 71 je 110b3c <_Thread_Handler+0xec> <== NOT EXECUTED 110acb: 73 37 jae 110b04 <_Thread_Handler+0xb4> <== NOT EXECUTED case THREAD_START_NUMERIC: executing->Wait.return_argument = 110acd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110ad0: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 110ad6: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 110adc: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 110adf: 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 ); 110ae2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110ae5: 53 push %ebx <== NOT EXECUTED 110ae6: e8 e5 c5 ff ff call 10d0d0 <_User_extensions_Thread_exitted> <== NOT EXECUTED _Internal_error_Occurred( 110aeb: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 110aee: 6a 06 push $0x6 <== NOT EXECUTED 110af0: 6a 01 push $0x1 <== NOT EXECUTED 110af2: 6a 00 push $0x0 <== NOT EXECUTED 110af4: e8 87 aa ff ff call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED 110af9: 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); 110afc: fb sti <== NOT EXECUTED 110afd: e9 6a ff ff ff jmp 110a6c <_Thread_Handler+0x1c> <== NOT EXECUTED 110b02: 66 90 xchg %ax,%ax <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 110b04: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 110b07: 74 4b je 110b54 <_Thread_Handler+0x104> <== NOT EXECUTED 110b09: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 110b0c: 75 d4 jne 110ae2 <_Thread_Handler+0x92> <== NOT EXECUTED executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 110b0e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 110b11: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 110b17: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 110b1d: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 110b23: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 110b26: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110b29: eb b7 jmp 110ae2 <_Thread_Handler+0x92> <== NOT EXECUTED 110b2b: 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 (); 110b2c: e8 ff 6d 00 00 call 117930 <__start_set_sysctl_set> <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 110b31: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax <== NOT EXECUTED 110b37: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 110b3a: 75 8f jne 110acb <_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 = 110b3c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110b3f: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 110b45: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 110b4b: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 110b4e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110b51: eb 8f jmp 110ae2 <_Thread_Handler+0x92> <== NOT EXECUTED 110b53: 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 = 110b54: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 110b57: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 110b5d: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 110b63: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 110b69: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 110b6c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110b6f: e9 6e ff ff ff jmp 110ae2 <_Thread_Handler+0x92> <== NOT EXECUTED 0010c5f8 <_Thread_Handler_initialization>: #if defined(RTEMS_MULTIPROCESSING) , uint32_t maximum_proxies #endif ) { 10c5f8: 55 push %ebp <== NOT EXECUTED 10c5f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c5fb: 53 push %ebx <== NOT EXECUTED 10c5fc: 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) 10c5ff: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10c604: 8b 58 20 mov 0x20(%eax),%ebx <== NOT EXECUTED 10c607: 85 db test %ebx,%ebx <== NOT EXECUTED 10c609: 0f 94 c2 sete %dl <== NOT EXECUTED 10c60c: 8b 48 24 mov 0x24(%eax),%ecx <== NOT EXECUTED 10c60f: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10c611: 0f 94 c0 sete %al <== NOT EXECUTED 10c614: 38 c2 cmp %al,%dl <== NOT EXECUTED 10c616: 0f 85 a5 00 00 00 jne 10c6c1 <_Thread_Handler_initialization+0xc9> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 10c61c: c6 05 8c f8 11 00 00 movb $0x0,0x11f88c <== NOT EXECUTED _Thread_Executing = NULL; 10c623: c7 05 7c f8 11 00 00 movl $0x0,0x11f87c <== NOT EXECUTED 10c62a: 00 00 00 <== NOT EXECUTED _Thread_Heir = NULL; 10c62d: c7 05 48 f8 11 00 00 movl $0x0,0x11f848 <== NOT EXECUTED 10c634: 00 00 00 <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; 10c637: c7 05 40 f8 11 00 00 movl $0x0,0x11f840 <== NOT EXECUTED 10c63e: 00 00 00 <== NOT EXECUTED #endif _Thread_Do_post_task_switch_extension = 0; 10c641: c7 05 60 f8 11 00 00 movl $0x0,0x11f860 <== NOT EXECUTED 10c648: 00 00 00 <== NOT EXECUTED _Thread_Maximum_extensions = maximum_extensions; 10c64b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c64e: a3 5c f8 11 00 mov %eax,0x11f85c <== NOT EXECUTED _Thread_Ticks_per_timeslice = ticks_per_timeslice; 10c653: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c656: a3 84 f7 11 00 mov %eax,0x11f784 <== NOT EXECUTED _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error( 10c65b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c65e: 0f b6 05 d4 b1 11 00 movzbl 0x11b1d4,%eax <== NOT EXECUTED 10c665: 8d 44 40 03 lea 0x3(%eax,%eax,2),%eax <== NOT EXECUTED 10c669: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10c66c: 50 push %eax <== NOT EXECUTED 10c66d: e8 26 0e 00 00 call 10d498 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10c672: a3 80 f7 11 00 mov %eax,0x11f780 <== NOT EXECUTED (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control) ); for ( index=0; index <= PRIORITY_MAXIMUM ; index++ ) 10c677: 0f b6 1d d4 b1 11 00 movzbl 0x11b1d4,%ebx <== NOT EXECUTED 10c67e: 89 c2 mov %eax,%edx <== NOT EXECUTED 10c680: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10c682: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c685: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10c688: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10c68b: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10c68d: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10c694: 89 52 08 mov %edx,0x8(%edx) <== NOT EXECUTED 10c697: 41 inc %ecx <== NOT EXECUTED 10c698: 83 c2 0c add $0xc,%edx <== NOT EXECUTED 10c69b: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 10c69d: 76 e9 jbe 10c688 <_Thread_Handler_initialization+0x90> <== NOT EXECUTED /* * Initialize this class of objects. */ _Objects_Initialize_information( 10c69f: 50 push %eax <== NOT EXECUTED 10c6a0: 6a 08 push $0x8 <== NOT EXECUTED 10c6a2: 6a 01 push $0x1 <== NOT EXECUTED 10c6a4: 68 08 01 00 00 push $0x108 <== NOT EXECUTED 10c6a9: 6a 01 push $0x1 <== NOT EXECUTED 10c6ab: 6a 01 push $0x1 <== NOT EXECUTED 10c6ad: 6a 01 push $0x1 <== NOT EXECUTED 10c6af: 68 40 f9 11 00 push $0x11f940 <== NOT EXECUTED 10c6b4: e8 b3 f4 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10c6b9: 83 c4 20 add $0x20,%esp <== NOT EXECUTED FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10c6bc: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c6bf: c9 leave <== NOT EXECUTED 10c6c0: 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( 10c6c1: 52 push %edx <== NOT EXECUTED 10c6c2: 6a 0f push $0xf <== NOT EXECUTED 10c6c4: 6a 01 push $0x1 <== NOT EXECUTED 10c6c6: 6a 00 push $0x0 <== NOT EXECUTED 10c6c8: e8 b3 ee ff ff call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED 0010c3f0 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10c3f0: 55 push %ebp <== NOT EXECUTED 10c3f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c3f3: 57 push %edi <== NOT EXECUTED 10c3f4: 56 push %esi <== NOT EXECUTED 10c3f5: 53 push %ebx <== NOT EXECUTED 10c3f6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c3f9: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10c3fc: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10c3ff: 8a 45 18 mov 0x18(%ebp),%al <== NOT EXECUTED 10c402: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED 10c405: 8a 4d 20 mov 0x20(%ebp),%cl <== NOT EXECUTED 10c408: 88 4d f2 mov %cl,-0xe(%ebp) <== NOT EXECUTED /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 10c40b: 85 d2 test %edx,%edx <== NOT EXECUTED 10c40d: 0f 84 b2 01 00 00 je 10c5c5 <_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; 10c413: c6 83 c0 00 00 00 00 movb $0x0,0xc0(%ebx) <== NOT EXECUTED 10c41a: 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 10c41d: 89 93 c8 00 00 00 mov %edx,0xc8(%ebx) <== NOT EXECUTED * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 10c423: 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 ) { 10c429: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10c42d: 0f 85 2d 01 00 00 jne 10c560 <_Thread_Initialize+0x170> <== NOT EXECUTED fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); if ( !fp_area ) { _Thread_Stack_Free( the_thread ); return FALSE; 10c433: 31 ff xor %edi,%edi <== NOT EXECUTED 10c435: 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; 10c437: 89 83 ec 00 00 00 mov %eax,0xec(%ebx) <== NOT EXECUTED the_thread->Start.fp_context = fp_area; 10c43d: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx) <== NOT EXECUTED * 10c443: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10c44a: 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 10c451: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) <== NOT EXECUTED * the heap 10c458: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED /* * Clear the libc reent hook. */ the_thread->libc_reent = NULL; 10c45f: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx) <== NOT EXECUTED 10c466: 00 00 00 <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c469: a1 5c f8 11 00 mov 0x11f85c,%eax <== NOT EXECUTED 10c46e: 85 c0 test %eax,%eax <== NOT EXECUTED 10c470: 0f 85 06 01 00 00 jne 10c57c <_Thread_Initialize+0x18c> <== NOT EXECUTED return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 10c476: c7 83 00 01 00 00 00 movl $0x0,0x100(%ebx) <== NOT EXECUTED 10c47d: 00 00 00 <== NOT EXECUTED 10c480: 31 f6 xor %esi,%esi <== NOT EXECUTED /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10c482: 8a 45 f2 mov -0xe(%ebp),%al <== NOT EXECUTED 10c485: 88 83 ac 00 00 00 mov %al,0xac(%ebx) <== NOT EXECUTED the_thread->Start.budget_algorithm = budget_algorithm; 10c48b: 8b 4d 24 mov 0x24(%ebp),%ecx <== NOT EXECUTED 10c48e: 89 8b b0 00 00 00 mov %ecx,0xb0(%ebx) <== NOT EXECUTED the_thread->Start.budget_callout = budget_callout; 10c494: 8b 45 28 mov 0x28(%ebp),%eax <== NOT EXECUTED 10c497: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx) <== NOT EXECUTED switch ( budget_algorithm ) { 10c49d: 83 f9 02 cmp $0x2,%ecx <== NOT EXECUTED 10c4a0: 75 08 jne 10c4aa <_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; 10c4a2: a1 84 f7 11 00 mov 0x11f784,%eax <== NOT EXECUTED 10c4a7: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 10c4aa: 8b 4d 2c mov 0x2c(%ebp),%ecx <== NOT EXECUTED 10c4ad: 89 8b b8 00 00 00 mov %ecx,0xb8(%ebx) <== NOT EXECUTED the_thread->current_state = STATES_DORMANT; 10c4b3: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) <== NOT EXECUTED the_thread->Wait.queue = NULL; 10c4ba: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED the_thread->resource_count = 0; 10c4c1: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) <== NOT EXECUTED the_thread->suspend_count = 0; 10c4c8: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED the_thread->real_priority = priority; 10c4cf: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 10c4d2: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED the_thread->Start.initial_priority = priority; 10c4d5: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) <== NOT EXECUTED _Thread_Set_priority( the_thread, priority ); 10c4db: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c4de: 50 push %eax <== NOT EXECUTED 10c4df: 53 push %ebx <== NOT EXECUTED 10c4e0: e8 af 06 00 00 call 10cb94 <_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; 10c4e5: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) <== NOT EXECUTED 10c4ec: 00 00 00 <== NOT EXECUTED the_thread->cpu_time_used.tv_nsec = 0; 10c4ef: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) <== NOT EXECUTED 10c4f6: 00 00 00 <== NOT EXECUTED 10c4f9: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 10c4fd: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c500: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 10c503: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10c506: 8b 45 30 mov 0x30(%ebp),%eax <== NOT EXECUTED 10c509: 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 ); 10c50c: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10c50f: e8 40 0c 00 00 call 10d154 <_User_extensions_Thread_create> <== NOT EXECUTED if ( !extension_status ) { 10c514: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c517: 84 c0 test %al,%al <== NOT EXECUTED 10c519: 75 39 jne 10c554 <_Thread_Initialize+0x164> <== NOT EXECUTED if ( extensions_area ) 10c51b: 85 f6 test %esi,%esi <== NOT EXECUTED 10c51d: 74 0c je 10c52b <_Thread_Initialize+0x13b> <== NOT EXECUTED (void) _Workspace_Free( extensions_area ); 10c51f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c522: 56 push %esi <== NOT EXECUTED 10c523: e8 40 0f 00 00 call 10d468 <_Workspace_Free> <== NOT EXECUTED 10c528: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 10c52b: 85 ff test %edi,%edi <== NOT EXECUTED 10c52d: 74 0c je 10c53b <_Thread_Initialize+0x14b> <== NOT EXECUTED (void) _Workspace_Free( fp_area ); 10c52f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c532: 57 push %edi <== NOT EXECUTED 10c533: e8 30 0f 00 00 call 10d468 <_Workspace_Free> <== NOT EXECUTED 10c538: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif _Thread_Stack_Free( the_thread ); 10c53b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c53e: 53 push %ebx <== NOT EXECUTED 10c53f: e8 6c 08 00 00 call 10cdb0 <_Thread_Stack_Free> <== NOT EXECUTED 10c544: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c546: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return FALSE; } return TRUE; } 10c549: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c54c: 5b pop %ebx <== NOT EXECUTED 10c54d: 5e pop %esi <== NOT EXECUTED 10c54e: 5f pop %edi <== NOT EXECUTED 10c54f: c9 leave <== NOT EXECUTED 10c550: c3 ret <== NOT EXECUTED 10c551: 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 ) { 10c554: b0 01 mov $0x1,%al <== NOT EXECUTED return FALSE; } return TRUE; } 10c556: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c559: 5b pop %ebx <== NOT EXECUTED 10c55a: 5e pop %esi <== NOT EXECUTED 10c55b: 5f pop %edi <== NOT EXECUTED 10c55c: c9 leave <== NOT EXECUTED 10c55d: c3 ret <== NOT EXECUTED 10c55e: 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 ); 10c560: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c563: 6a 6c push $0x6c <== NOT EXECUTED 10c565: e8 16 0f 00 00 call 10d480 <_Workspace_Allocate> <== NOT EXECUTED 10c56a: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( !fp_area ) { 10c56c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c56f: 85 c0 test %eax,%eax <== NOT EXECUTED 10c571: 0f 85 c0 fe ff ff jne 10c437 <_Thread_Initialize+0x47> <== NOT EXECUTED 10c577: eb c2 jmp 10c53b <_Thread_Initialize+0x14b> <== NOT EXECUTED 10c579: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { extensions_area = _Workspace_Allocate( 10c57c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c57f: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax <== NOT EXECUTED 10c586: 50 push %eax <== NOT EXECUTED 10c587: e8 f4 0e 00 00 call 10d480 <_Workspace_Allocate> <== NOT EXECUTED 10c58c: 89 c6 mov %eax,%esi <== NOT EXECUTED (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 10c58e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c591: 85 c0 test %eax,%eax <== NOT EXECUTED 10c593: 74 96 je 10c52b <_Thread_Initialize+0x13b> <== NOT EXECUTED return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 10c595: 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++ ) 10c59b: 83 3d 5c f8 11 00 ff cmpl $0xffffffff,0x11f85c <== NOT EXECUTED 10c5a2: 0f 84 da fe ff ff je 10c482 <_Thread_Initialize+0x92> <== NOT EXECUTED 10c5a8: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c5aa: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10c5ac: a1 5c f8 11 00 mov 0x11f85c,%eax <== NOT EXECUTED 10c5b1: 40 inc %eax <== NOT EXECUTED 10c5b2: 66 90 xchg %ax,%ax <== NOT EXECUTED the_thread->extensions[i] = NULL; 10c5b4: 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++ ) 10c5bb: 42 inc %edx <== NOT EXECUTED 10c5bc: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10c5be: 77 f4 ja 10c5b4 <_Thread_Initialize+0x1c4> <== NOT EXECUTED 10c5c0: e9 bd fe ff ff jmp 10c482 <_Thread_Initialize+0x92> <== NOT EXECUTED */ if ( !stack_area ) { actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10c5c5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c5c8: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10c5cb: 53 push %ebx <== NOT EXECUTED 10c5cc: e8 7b 07 00 00 call 10cd4c <_Thread_Stack_Allocate> <== NOT EXECUTED if ( !actual_stack_size || actual_stack_size < stack_size ) 10c5d1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c5d4: 85 c0 test %eax,%eax <== NOT EXECUTED 10c5d6: 74 17 je 10c5ef <_Thread_Initialize+0x1ff> <== NOT EXECUTED 10c5d8: 39 45 14 cmp %eax,0x14(%ebp) <== NOT EXECUTED 10c5db: 77 12 ja 10c5ef <_Thread_Initialize+0x1ff> <== NOT EXECUTED return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 10c5dd: 8b 93 d0 00 00 00 mov 0xd0(%ebx),%edx <== NOT EXECUTED the_thread->Start.core_allocated_stack = TRUE; 10c5e3: c6 83 c0 00 00 00 01 movb $0x1,0xc0(%ebx) <== NOT EXECUTED 10c5ea: e9 2e fe ff ff jmp 10c41d <_Thread_Initialize+0x2d> <== NOT EXECUTED (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); return FALSE; 10c5ef: 31 c0 xor %eax,%eax 10c5f1: e9 53 ff ff ff jmp 10c549 <_Thread_Initialize+0x159> <== NOT EXECUTED 0010fb78 <_Thread_Load_environment>: */ void _Thread_Load_environment( Thread_Control *the_thread ) { 10fb78: 55 push %ebp <== NOT EXECUTED 10fb79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fb7b: 57 push %edi <== NOT EXECUTED 10fb7c: 56 push %esi <== NOT EXECUTED 10fb7d: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10fb80: 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 ) { 10fb83: 8b ba cc 00 00 00 mov 0xcc(%edx),%edi <== NOT EXECUTED 10fb89: 85 ff test %edi,%edi <== NOT EXECUTED 10fb8b: 74 12 je 10fb9f <_Thread_Load_environment+0x27> <== NOT EXECUTED the_thread->fp_context = the_thread->Start.fp_context; 10fb8d: 89 ba ec 00 00 00 mov %edi,0xec(%edx) <== NOT EXECUTED _Context_Initialize_fp( &the_thread->fp_context ); 10fb93: be a0 f9 11 00 mov $0x11f9a0,%esi <== NOT EXECUTED 10fb98: b9 1b 00 00 00 mov $0x1b,%ecx <== NOT EXECUTED 10fb9d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED } else #endif is_fp = false; the_thread->do_post_task_switch_extension = false; 10fb9f: c6 42 75 00 movb $0x0,0x75(%edx) <== NOT EXECUTED the_thread->is_preemptible = the_thread->Start.is_preemptible; 10fba3: 8a 82 ac 00 00 00 mov 0xac(%edx),%al <== NOT EXECUTED 10fba9: 88 42 76 mov %al,0x76(%edx) <== NOT EXECUTED the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 10fbac: 8b 82 b0 00 00 00 mov 0xb0(%edx),%eax <== NOT EXECUTED 10fbb2: 89 42 7c mov %eax,0x7c(%edx) <== NOT EXECUTED the_thread->budget_callout = the_thread->Start.budget_callout; 10fbb5: 8b 82 b4 00 00 00 mov 0xb4(%edx),%eax <== NOT EXECUTED 10fbbb: 89 82 80 00 00 00 mov %eax,0x80(%edx) <== NOT EXECUTED _Context_Initialize( 10fbc1: 83 ba b8 00 00 00 01 cmpl $0x1,0xb8(%edx) <== NOT EXECUTED 10fbc8: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10fbca: 25 00 02 00 00 and $0x200,%eax <== NOT EXECUTED 10fbcf: 05 02 30 00 00 add $0x3002,%eax <== NOT EXECUTED 10fbd4: 89 82 d4 00 00 00 mov %eax,0xd4(%edx) <== NOT EXECUTED 10fbda: 8b 82 c4 00 00 00 mov 0xc4(%edx),%eax <== NOT EXECUTED 10fbe0: 83 e8 04 sub $0x4,%eax <== NOT EXECUTED 10fbe3: 03 82 c8 00 00 00 add 0xc8(%edx),%eax <== NOT EXECUTED 10fbe9: c7 00 50 0a 11 00 movl $0x110a50,(%eax) <== NOT EXECUTED 10fbef: 89 82 dc 00 00 00 mov %eax,0xdc(%edx) <== NOT EXECUTED 10fbf5: 89 82 d8 00 00 00 mov %eax,0xd8(%edx) <== NOT EXECUTED the_thread->Start.isr_level, _Thread_Handler, is_fp ); } 10fbfb: 58 pop %eax <== NOT EXECUTED 10fbfc: 5e pop %esi <== NOT EXECUTED 10fbfd: 5f pop %edi <== NOT EXECUTED 10fbfe: c9 leave <== NOT EXECUTED 10fbff: c3 ret <== NOT EXECUTED 0010fdfc <_Thread_Ready>: */ void _Thread_Ready( Thread_Control *the_thread ) { 10fdfc: 55 push %ebp <== NOT EXECUTED 10fdfd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fdff: 53 push %ebx <== NOT EXECUTED 10fe00: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Thread_Control *heir; _ISR_Disable( level ); 10fe03: 9c pushf <== NOT EXECUTED 10fe04: fa cli <== NOT EXECUTED 10fe05: 5b pop %ebx <== NOT EXECUTED the_thread->current_state = STATES_READY; 10fe06: 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 10fe0d: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10fe13: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10fe1a: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10fe1d: 66 a1 70 f8 11 00 mov 0x11f870,%ax <== NOT EXECUTED 10fe23: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10fe29: 66 a3 70 f8 11 00 mov %ax,0x11f870 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node ); 10fe2f: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10fe35: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10fe38: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10fe3a: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10fe3d: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10fe40: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10fe42: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10fe45: 53 push %ebx <== NOT EXECUTED 10fe46: 9d popf <== NOT EXECUTED 10fe47: fa cli <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10fe48: 66 8b 0d 70 f8 11 00 mov 0x11f870,%cx <== NOT EXECUTED 10fe4f: 31 d2 xor %edx,%edx <== NOT EXECUTED 10fe51: 89 d0 mov %edx,%eax <== NOT EXECUTED 10fe53: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10fe57: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10fe5a: 66 8b 8c 00 00 f9 11 mov 0x11f900(%eax,%eax,1),%cx <== NOT EXECUTED 10fe61: 00 <== NOT EXECUTED 10fe62: 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. 10fe66: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10fe69: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10fe6c: 01 d0 add %edx,%eax <== NOT EXECUTED 10fe6e: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10fe71: 8b 15 80 f7 11 00 mov 0x11f780,%edx <== NOT EXECUTED 10fe77: 8b 04 82 mov (%edx,%eax,4),%eax <== NOT EXECUTED 10fe7a: a3 48 f8 11 00 mov %eax,0x11f848 <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10fe7f: 8b 15 7c f8 11 00 mov 0x11f87c,%edx <== NOT EXECUTED _Thread_Calculate_heir(); heir = _Thread_Heir; if ( !_Thread_Is_executing( heir ) && _Thread_Executing->is_preemptible ) 10fe85: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10fe87: 74 0d je 10fe96 <_Thread_Ready+0x9a> <== NOT EXECUTED 10fe89: 80 7a 76 00 cmpb $0x0,0x76(%edx) <== NOT EXECUTED 10fe8d: 74 07 je 10fe96 <_Thread_Ready+0x9a> <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10fe8f: c6 05 8c f8 11 00 01 movb $0x1,0x11f88c <== NOT EXECUTED _ISR_Enable( level ); 10fe96: 53 push %ebx <== NOT EXECUTED 10fe97: 9d popf <== NOT EXECUTED } 10fe98: 5b pop %ebx <== NOT EXECUTED 10fe99: c9 leave <== NOT EXECUTED 10fe9a: c3 ret <== NOT EXECUTED 00110a34 <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 110a34: 55 push %ebp <== NOT EXECUTED 110a35: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110a37: 53 push %ebx <== NOT EXECUTED 110a38: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 110a3b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED the_thread->resource_count = 0; 110a3e: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) <== NOT EXECUTED the_thread->suspend_count = 0; 110a45: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED the_thread->is_preemptible = the_thread->Start.is_preemptible; 110a4c: 8a 83 ac 00 00 00 mov 0xac(%ebx),%al <== NOT EXECUTED 110a52: 88 43 76 mov %al,0x76(%ebx) <== NOT EXECUTED the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 110a55: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 110a5b: 89 43 7c mov %eax,0x7c(%ebx) <== NOT EXECUTED the_thread->budget_callout = the_thread->Start.budget_callout; 110a5e: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax <== NOT EXECUTED 110a64: 89 83 80 00 00 00 mov %eax,0x80(%ebx) <== NOT EXECUTED the_thread->Start.pointer_argument = pointer_argument; 110a6a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 110a6d: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) <== NOT EXECUTED the_thread->Start.numeric_argument = numeric_argument; 110a73: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 110a76: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) <== NOT EXECUTED if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 110a7c: 53 push %ebx <== NOT EXECUTED 110a7d: e8 ce c9 ff ff call 10d450 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 110a82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110a85: 84 c0 test %al,%al <== NOT EXECUTED 110a87: 75 06 jne 110a8f <_Thread_Reset+0x5b> <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 110a89: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 110a8d: 74 25 je 110ab4 <_Thread_Reset+0x80> <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 110a8f: 8b 83 bc 00 00 00 mov 0xbc(%ebx),%eax <== NOT EXECUTED 110a95: 39 43 14 cmp %eax,0x14(%ebx) <== NOT EXECUTED 110a98: 74 12 je 110aac <_Thread_Reset+0x78> <== NOT EXECUTED the_thread->real_priority = the_thread->Start.initial_priority; 110a9a: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 110a9d: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 110aa0: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 110aa3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110aa6: 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 ); 110aa7: e9 a4 cb ff ff jmp 10d650 <_Thread_Set_priority> <== NOT EXECUTED } } 110aac: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110aaf: c9 leave <== NOT EXECUTED 110ab0: c3 ret <== NOT EXECUTED 110ab1: 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 ); 110ab4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110ab7: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 110aba: 50 push %eax <== NOT EXECUTED 110abb: e8 c8 d3 ff ff call 10de88 <_Watchdog_Remove> <== NOT EXECUTED 110ac0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110ac3: eb ca jmp 110a8f <_Thread_Reset+0x5b> <== NOT EXECUTED 0010fe9c <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 10fe9c: 55 push %ebp <== NOT EXECUTED 10fe9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fe9f: 56 push %esi <== NOT EXECUTED 10fea0: 53 push %ebx <== NOT EXECUTED ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10fea1: 8b 0d 7c f8 11 00 mov 0x11f87c,%ecx <== NOT EXECUTED ready = executing->ready; 10fea7: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx <== NOT EXECUTED _ISR_Disable( level ); 10fead: 9c pushf <== NOT EXECUTED 10feae: fa cli <== NOT EXECUTED 10feaf: 5e pop %esi <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10feb0: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10feb2: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10feb5: 74 35 je 10feec <_Thread_Reset_timeslice+0x50> <== NOT EXECUTED 10feb7: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10feb9: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10febc: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10febf: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10fec1: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 10fec4: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10fec6: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10fec9: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED 10fecc: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10fece: 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 ); 10fed1: 56 push %esi <== NOT EXECUTED 10fed2: 9d popf <== NOT EXECUTED 10fed3: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( executing ) ) 10fed4: 3b 0d 48 f8 11 00 cmp 0x11f848,%ecx <== NOT EXECUTED 10feda: 74 18 je 10fef4 <_Thread_Reset_timeslice+0x58> <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; 10fedc: c6 05 8c f8 11 00 01 movb $0x1,0x11f88c <== NOT EXECUTED _ISR_Enable( level ); 10fee3: 56 push %esi <== NOT EXECUTED 10fee4: 9d popf <== NOT EXECUTED } 10fee5: 5b pop %ebx <== NOT EXECUTED 10fee6: 5e pop %esi <== NOT EXECUTED 10fee7: c9 leave <== NOT EXECUTED 10fee8: c3 ret <== NOT EXECUTED 10fee9: 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 ); 10feec: 56 push %esi <== NOT EXECUTED 10feed: 9d popf <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10feee: 5b pop %ebx <== NOT EXECUTED 10feef: 5e pop %esi <== NOT EXECUTED 10fef0: c9 leave <== NOT EXECUTED 10fef1: c3 ret <== NOT EXECUTED 10fef2: 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; 10fef4: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10fef6: a3 48 f8 11 00 mov %eax,0x11f848 <== NOT EXECUTED 10fefb: eb df jmp 10fedc <_Thread_Reset_timeslice+0x40> <== NOT EXECUTED 0010d5bc <_Thread_Restart>: bool _Thread_Restart( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10d5bc: 55 push %ebp <== NOT EXECUTED 10d5bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d5bf: 53 push %ebx <== NOT EXECUTED 10d5c0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d5c3: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( !_States_Is_dormant( the_thread->current_state ) ) { 10d5c6: f6 43 10 01 testb $0x1,0x10(%ebx) <== NOT EXECUTED 10d5ca: 74 08 je 10d5d4 <_Thread_Restart+0x18> <== NOT EXECUTED 10d5cc: 31 c0 xor %eax,%eax <== NOT EXECUTED return TRUE; } return FALSE; } 10d5ce: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d5d1: c9 leave <== NOT EXECUTED 10d5d2: c3 ret <== NOT EXECUTED 10d5d3: 90 nop <== NOT EXECUTED Thread_Entry_numeric_type numeric_argument ) { if ( !_States_Is_dormant( the_thread->current_state ) ) { _Thread_Set_transient( the_thread ); 10d5d4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d5d7: 53 push %ebx <== NOT EXECUTED 10d5d8: e8 b7 01 00 00 call 10d794 <_Thread_Set_transient> <== NOT EXECUTED _Thread_Reset( the_thread, pointer_argument, numeric_argument ); 10d5dd: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10d5e0: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10d5e3: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d5e6: 53 push %ebx <== NOT EXECUTED 10d5e7: e8 48 34 00 00 call 110a34 <_Thread_Reset> <== NOT EXECUTED _Thread_Load_environment( the_thread ); 10d5ec: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10d5ef: e8 1c 31 00 00 call 110710 <_Thread_Load_environment> <== NOT EXECUTED _Thread_Ready( the_thread ); 10d5f4: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10d5f7: e8 98 33 00 00 call 110994 <_Thread_Ready> <== NOT EXECUTED _User_extensions_Thread_restart( the_thread ); 10d5fc: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10d5ff: e8 94 06 00 00 call 10dc98 <_User_extensions_Thread_restart> <== NOT EXECUTED if ( _Thread_Is_executing ( the_thread ) ) 10d604: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d607: 3b 1d 5c 2e 12 00 cmp 0x122e5c,%ebx <== NOT EXECUTED 10d60d: 74 09 je 10d618 <_Thread_Restart+0x5c> <== NOT EXECUTED 10d60f: b0 01 mov $0x1,%al <== NOT EXECUTED return TRUE; } return FALSE; } 10d611: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d614: c9 leave <== NOT EXECUTED 10d615: c3 ret <== NOT EXECUTED 10d616: 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 10d618: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax <== NOT EXECUTED 10d61e: 85 c0 test %eax,%eax <== NOT EXECUTED 10d620: 74 12 je 10d634 <_Thread_Restart+0x78> <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10d622: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d625: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax <== NOT EXECUTED 10d62b: 50 push %eax <== NOT EXECUTED 10d62c: e8 2d 0a 00 00 call 10e05e <_CPU_Context_restore_fp> <== NOT EXECUTED 10d631: 83 c4 10 add $0x10,%esp <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, 10d634: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d637: a1 5c 2e 12 00 mov 0x122e5c,%eax <== NOT EXECUTED 10d63c: 05 d4 00 00 00 add $0xd4,%eax <== NOT EXECUTED 10d641: 50 push %eax <== NOT EXECUTED 10d642: e8 06 0a 00 00 call 10e04d <_CPU_Context_restore> <== NOT EXECUTED 10d647: b0 01 mov $0x1,%al <== NOT EXECUTED 10d649: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d64c: eb 80 jmp 10d5ce <_Thread_Restart+0x12> <== NOT EXECUTED 0010e08c <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, bool force ) { 10e08c: 55 push %ebp <== NOT EXECUTED 10e08d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e08f: 53 push %ebx <== NOT EXECUTED 10e090: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10e093: 8a 45 0c mov 0xc(%ebp),%al <== NOT EXECUTED ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10e096: 9c pushf <== NOT EXECUTED 10e097: fa cli <== NOT EXECUTED 10e098: 5b pop %ebx <== NOT EXECUTED if ( force == TRUE ) 10e099: 84 c0 test %al,%al <== NOT EXECUTED 10e09b: 74 13 je 10e0b0 <_Thread_Resume+0x24> <== NOT EXECUTED the_thread->suspend_count = 0; 10e09d: 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; 10e0a4: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED if ( current_state & STATES_SUSPENDED ) { 10e0a7: a8 02 test $0x2,%al <== NOT EXECUTED 10e0a9: 75 15 jne 10e0c0 <_Thread_Resume+0x34> <== NOT EXECUTED _Context_Switch_necessary = TRUE; } } } _ISR_Enable( level ); 10e0ab: 53 push %ebx <== NOT EXECUTED 10e0ac: 9d popf <== NOT EXECUTED } 10e0ad: 5b pop %ebx <== NOT EXECUTED 10e0ae: c9 leave <== NOT EXECUTED 10e0af: c3 ret <== NOT EXECUTED _ISR_Disable( level ); if ( force == TRUE ) the_thread->suspend_count = 0; else the_thread->suspend_count--; 10e0b0: 8b 41 70 mov 0x70(%ecx),%eax <== NOT EXECUTED 10e0b3: 48 dec %eax <== NOT EXECUTED 10e0b4: 89 41 70 mov %eax,0x70(%ecx) <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 10e0b7: 85 c0 test %eax,%eax <== NOT EXECUTED 10e0b9: 74 e9 je 10e0a4 <_Thread_Resume+0x18> <== NOT EXECUTED _ISR_Enable( level ); 10e0bb: 53 push %ebx <== NOT EXECUTED 10e0bc: 9d popf <== NOT EXECUTED } } } _ISR_Enable( level ); } 10e0bd: 5b pop %ebx <== NOT EXECUTED 10e0be: c9 leave <== NOT EXECUTED 10e0bf: 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( 10e0c0: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED return; } current_state = the_thread->current_state; if ( current_state & STATES_SUSPENDED ) { current_state = 10e0c3: 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 ) ) { 10e0c6: 85 c0 test %eax,%eax <== NOT EXECUTED 10e0c8: 75 e1 jne 10e0ab <_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 10e0ca: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10e0d0: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10e0d7: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10e0da: 66 a1 90 b8 12 00 mov 0x12b890,%ax <== NOT EXECUTED 10e0e0: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10e0e6: 66 a3 90 b8 12 00 mov %ax,0x12b890 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10e0ec: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10e0f2: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10e0f5: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10e0f7: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10e0fa: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10e0fd: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10e0ff: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10e102: 53 push %ebx <== NOT EXECUTED 10e103: 9d popf <== NOT EXECUTED 10e104: fa cli <== NOT EXECUTED if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 10e105: 8b 51 14 mov 0x14(%ecx),%edx <== NOT EXECUTED 10e108: a1 68 b8 12 00 mov 0x12b868,%eax <== NOT EXECUTED 10e10d: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10e110: 73 99 jae 10e0ab <_Thread_Resume+0x1f> <== NOT EXECUTED _Thread_Heir = the_thread; 10e112: 89 0d 68 b8 12 00 mov %ecx,0x12b868 <== NOT EXECUTED if ( _Thread_Executing->is_preemptible || 10e118: a1 9c b8 12 00 mov 0x12b89c,%eax <== NOT EXECUTED 10e11d: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10e121: 74 0d je 10e130 <_Thread_Resume+0xa4> <== NOT EXECUTED the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 10e123: c6 05 ac b8 12 00 01 movb $0x1,0x12b8ac <== NOT EXECUTED 10e12a: e9 7c ff ff ff jmp 10e0ab <_Thread_Resume+0x1f> <== NOT EXECUTED 10e12f: 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 || 10e130: 85 d2 test %edx,%edx <== NOT EXECUTED 10e132: 0f 85 73 ff ff ff jne 10e0ab <_Thread_Resume+0x1f> <== NOT EXECUTED 10e138: eb e9 jmp 10e123 <_Thread_Resume+0x97> <== NOT EXECUTED 0010cb94 <_Thread_Set_priority>: void _Thread_Set_priority( Thread_Control *the_thread, Priority_Control new_priority ) { 10cb94: 55 push %ebp <== NOT EXECUTED 10cb95: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cb97: 56 push %esi <== NOT EXECUTED 10cb98: 53 push %ebx <== NOT EXECUTED 10cb99: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10cb9c: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED the_thread->current_priority = new_priority; 10cb9f: 89 53 14 mov %edx,0x14(%ebx) <== NOT EXECUTED the_thread->ready = &_Thread_Ready_chain[ new_priority ]; 10cba2: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10cba5: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10cba8: 03 05 80 f7 11 00 add 0x11f780,%eax <== NOT EXECUTED 10cbae: 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. */ 10cbb4: 89 d1 mov %edx,%ecx <== NOT EXECUTED 10cbb6: c1 e9 04 shr $0x4,%ecx <== NOT EXECUTED bool _Protected_heap_Walk( Heap_Control *the_heap, int source, 10cbb9: 0f b7 c9 movzwl %cx,%ecx <== NOT EXECUTED 10cbbc: 8d 84 09 00 f9 11 00 lea 0x11f900(%ecx,%ecx,1),%eax <== NOT EXECUTED 10cbc3: 89 83 90 00 00 00 mov %eax,0x90(%ebx) <== NOT EXECUTED bool do_dump ); 10cbc9: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10cbce: 89 c6 mov %eax,%esi <== NOT EXECUTED 10cbd0: d3 e6 shl %cl,%esi <== NOT EXECUTED 10cbd2: 89 f1 mov %esi,%ecx <== NOT EXECUTED /** 10cbd4: 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 10cbdb: f7 d1 not %ecx <== NOT EXECUTED 10cbdd: 66 89 8b 98 00 00 00 mov %cx,0x98(%ebx) <== NOT EXECUTED * sizes. * 10cbe4: 83 e2 0f and $0xf,%edx <== NOT EXECUTED 10cbe7: 88 d1 mov %dl,%cl <== NOT EXECUTED 10cbe9: d3 e0 shl %cl,%eax <== NOT EXECUTED * @param[in] the_heap pointer to heap header 10cbeb: 66 89 83 96 00 00 00 mov %ax,0x96(%ebx) <== NOT EXECUTED * @param[in] the_info pointer to a status information area 10cbf2: f7 d0 not %eax <== NOT EXECUTED 10cbf4: 66 89 83 9a 00 00 00 mov %ax,0x9a(%ebx) <== NOT EXECUTED _Priority_Initialize_information( &the_thread->Priority_map, new_priority ); } 10cbfb: 5b pop %ebx <== NOT EXECUTED 10cbfc: 5e pop %esi <== NOT EXECUTED 10cbfd: c9 leave <== NOT EXECUTED 10cbfe: c3 ret <== NOT EXECUTED 0010cc00 <_Thread_Set_state>: void _Thread_Set_state( Thread_Control *the_thread, States_Control state ) { 10cc00: 55 push %ebp <== NOT EXECUTED 10cc01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cc03: 56 push %esi <== NOT EXECUTED 10cc04: 53 push %ebx <== NOT EXECUTED 10cc05: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10cc08: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Chain_Control *ready; ready = the_thread->ready; 10cc0b: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx <== NOT EXECUTED _ISR_Disable( level ); 10cc11: 9c pushf <== NOT EXECUTED 10cc12: fa cli <== NOT EXECUTED 10cc13: 5e pop %esi <== NOT EXECUTED if ( !_States_Is_ready( the_thread->current_state ) ) { 10cc14: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10cc17: 85 c0 test %eax,%eax <== NOT EXECUTED 10cc19: 75 2d jne 10cc48 <_Thread_Set_state+0x48> <== NOT EXECUTED _States_Set( state, the_thread->current_state ); _ISR_Enable( level ); return; } the_thread->current_state = state; 10cc1b: 89 4b 10 mov %ecx,0x10(%ebx) <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10cc1e: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10cc20: 3b 42 08 cmp 0x8(%edx),%eax <== NOT EXECUTED 10cc23: 74 2f je 10cc54 <_Thread_Set_state+0x54> <== NOT EXECUTED 10cc25: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10cc27: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10cc2a: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10cc2d: 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 ); 10cc2f: 56 push %esi <== NOT EXECUTED 10cc30: 9d popf <== NOT EXECUTED 10cc31: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) 10cc32: 3b 1d 48 f8 11 00 cmp 0x11f848,%ebx <== NOT EXECUTED 10cc38: 74 62 je 10cc9c <_Thread_Set_state+0x9c> <== NOT EXECUTED _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) 10cc3a: 3b 1d 7c f8 11 00 cmp 0x11f87c,%ebx <== NOT EXECUTED 10cc40: 74 4e je 10cc90 <_Thread_Set_state+0x90> <== NOT EXECUTED _Context_Switch_necessary = TRUE; _ISR_Enable( level ); 10cc42: 56 push %esi <== NOT EXECUTED 10cc43: 9d popf <== NOT EXECUTED } 10cc44: 5b pop %ebx <== NOT EXECUTED 10cc45: 5e pop %esi <== NOT EXECUTED 10cc46: c9 leave <== NOT EXECUTED 10cc47: 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 = 10cc48: 09 c1 or %eax,%ecx <== NOT EXECUTED 10cc4a: 89 4b 10 mov %ecx,0x10(%ebx) <== NOT EXECUTED _States_Set( state, the_thread->current_state ); _ISR_Enable( level ); 10cc4d: 56 push %esi <== NOT EXECUTED 10cc4e: 9d popf <== NOT EXECUTED if ( _Thread_Is_executing( the_thread ) ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10cc4f: 5b pop %ebx <== NOT EXECUTED 10cc50: 5e pop %esi <== NOT EXECUTED 10cc51: c9 leave <== NOT EXECUTED 10cc52: c3 ret <== NOT EXECUTED 10cc53: 90 nop <== NOT EXECUTED 10cc54: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10cc57: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10cc59: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10cc60: 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 10cc63: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax <== NOT EXECUTED 10cc69: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx <== NOT EXECUTED 10cc70: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10cc73: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10cc77: 75 b6 jne 10cc2f <_Thread_Set_state+0x2f> <== NOT EXECUTED * to be resized 10cc79: 66 a1 70 f8 11 00 mov 0x11f870,%ax <== NOT EXECUTED 10cc7f: 23 83 98 00 00 00 and 0x98(%ebx),%eax <== NOT EXECUTED 10cc85: 66 a3 70 f8 11 00 mov %ax,0x11f870 <== NOT EXECUTED 10cc8b: eb a2 jmp 10cc2f <_Thread_Set_state+0x2f> <== NOT EXECUTED 10cc8d: 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; 10cc90: c6 05 8c f8 11 00 01 movb $0x1,0x11f88c <== NOT EXECUTED 10cc97: eb a9 jmp 10cc42 <_Thread_Set_state+0x42> <== NOT EXECUTED 10cc99: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10cc9c: 66 8b 0d 70 f8 11 00 mov 0x11f870,%cx <== NOT EXECUTED 10cca3: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cca5: 89 d0 mov %edx,%eax <== NOT EXECUTED 10cca7: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10ccab: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10ccae: 66 8b 8c 00 00 f9 11 mov 0x11f900(%eax,%eax,1),%cx <== NOT EXECUTED 10ccb5: 00 <== NOT EXECUTED 10ccb6: 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. 10ccba: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10ccbd: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10ccc0: 01 d0 add %edx,%eax <== NOT EXECUTED 10ccc2: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10ccc5: 8b 15 80 f7 11 00 mov 0x11f780,%edx <== NOT EXECUTED 10cccb: 8b 04 82 mov (%edx,%eax,4),%eax <== NOT EXECUTED 10ccce: a3 48 f8 11 00 mov %eax,0x11f848 <== NOT EXECUTED 10ccd3: e9 62 ff ff ff jmp 10cc3a <_Thread_Set_state+0x3a> <== NOT EXECUTED 0010ccd8 <_Thread_Set_transient>: */ void _Thread_Set_transient( Thread_Control *the_thread ) { 10ccd8: 55 push %ebp <== NOT EXECUTED 10ccd9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ccdb: 56 push %esi <== NOT EXECUTED 10ccdc: 53 push %ebx <== NOT EXECUTED 10ccdd: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; uint32_t old_state; Chain_Control *ready; ready = the_thread->ready; 10cce0: 8b 8b 8c 00 00 00 mov 0x8c(%ebx),%ecx <== NOT EXECUTED _ISR_Disable( level ); 10cce6: 9c pushf <== NOT EXECUTED 10cce7: fa cli <== NOT EXECUTED 10cce8: 5e pop %esi <== NOT EXECUTED old_state = the_thread->current_state; 10cce9: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED the_thread->current_state = _States_Set( STATES_TRANSIENT, old_state ); 10ccec: 89 d0 mov %edx,%eax <== NOT EXECUTED 10ccee: 83 c8 04 or $0x4,%eax <== NOT EXECUTED 10ccf1: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED if ( _States_Is_ready( old_state ) ) { 10ccf4: 85 d2 test %edx,%edx <== NOT EXECUTED 10ccf6: 75 11 jne 10cd09 <_Thread_Set_transient+0x31> <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10ccf8: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10ccfa: 3b 41 08 cmp 0x8(%ecx),%eax <== NOT EXECUTED 10ccfd: 74 11 je 10cd10 <_Thread_Set_transient+0x38> <== NOT EXECUTED 10ccff: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10cd01: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10cd04: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10cd07: 89 10 mov %edx,(%eax) <== NOT EXECUTED } else _Chain_Extract_unprotected( &the_thread->Object.Node ); } _ISR_Enable( level ); 10cd09: 56 push %esi <== NOT EXECUTED 10cd0a: 9d popf <== NOT EXECUTED } 10cd0b: 5b pop %ebx <== NOT EXECUTED 10cd0c: 5e pop %esi <== NOT EXECUTED 10cd0d: c9 leave <== NOT EXECUTED 10cd0e: c3 ret <== NOT EXECUTED 10cd0f: 90 nop <== NOT EXECUTED 10cd10: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10cd13: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10cd15: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10cd1c: 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 10cd1f: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax <== NOT EXECUTED 10cd25: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx <== NOT EXECUTED 10cd2c: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10cd2f: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10cd33: 75 d4 jne 10cd09 <_Thread_Set_transient+0x31> <== NOT EXECUTED * to be resized 10cd35: 66 a1 70 f8 11 00 mov 0x11f870,%ax <== NOT EXECUTED 10cd3b: 23 83 98 00 00 00 and 0x98(%ebx),%eax <== NOT EXECUTED 10cd41: 66 a3 70 f8 11 00 mov %ax,0x11f870 <== NOT EXECUTED 10cd47: eb c0 jmp 10cd09 <_Thread_Set_transient+0x31> <== NOT EXECUTED 0010cd4c <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 10cd4c: 55 push %ebp <== NOT EXECUTED 10cd4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cd4f: 53 push %ebx <== NOT EXECUTED 10cd50: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10cd53: a1 d0 b1 11 00 mov 0x11b1d0,%eax <== NOT EXECUTED 10cd58: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10cd5b: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10cd5d: 73 02 jae 10cd61 <_Thread_Stack_Allocate+0x15> <== NOT EXECUTED 10cd5f: 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 ) { 10cd61: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10cd66: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED 10cd69: 85 c0 test %eax,%eax <== NOT EXECUTED 10cd6b: 74 33 je 10cda0 <_Thread_Stack_Allocate+0x54> <== NOT EXECUTED stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size ); 10cd6d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cd70: 53 push %ebx <== NOT EXECUTED 10cd71: ff d0 call *%eax <== NOT EXECUTED 10cd73: 89 c2 mov %eax,%edx <== NOT EXECUTED 10cd75: 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 ) 10cd78: 85 d2 test %edx,%edx <== NOT EXECUTED 10cd7a: 74 10 je 10cd8c <_Thread_Stack_Allocate+0x40> <== NOT EXECUTED the_stack_size = 0; the_thread->Start.stack = stack_addr; 10cd7c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cd7f: 89 90 d0 00 00 00 mov %edx,0xd0(%eax) <== NOT EXECUTED return the_stack_size; } 10cd85: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10cd87: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cd8a: c9 leave <== NOT EXECUTED 10cd8b: c3 ret <== NOT EXECUTED the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 10cd8c: 31 db xor %ebx,%ebx <== NOT EXECUTED the_stack_size = 0; the_thread->Start.stack = stack_addr; 10cd8e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cd91: 89 90 d0 00 00 00 mov %edx,0xd0(%eax) <== NOT EXECUTED return the_stack_size; } 10cd97: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10cd99: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cd9c: c9 leave <== NOT EXECUTED 10cd9d: c3 ret <== NOT EXECUTED 10cd9e: 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 ); 10cda0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cda3: 53 push %ebx <== NOT EXECUTED 10cda4: e8 d7 06 00 00 call 10d480 <_Workspace_Allocate> <== NOT EXECUTED 10cda9: 89 c2 mov %eax,%edx <== NOT EXECUTED 10cdab: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cdae: eb c8 jmp 10cd78 <_Thread_Stack_Allocate+0x2c> <== NOT EXECUTED 0010cdb0 <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 10cdb0: 55 push %ebp <== NOT EXECUTED 10cdb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cdb3: 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 ) 10cdb6: 80 ba c0 00 00 00 00 cmpb $0x0,0xc0(%edx) <== NOT EXECUTED 10cdbd: 74 19 je 10cdd8 <_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 ) 10cdbf: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10cdc4: 8b 48 24 mov 0x24(%eax),%ecx <== NOT EXECUTED 10cdc7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10cdc9: 74 11 je 10cddc <_Thread_Stack_Free+0x2c> <== NOT EXECUTED (*_Configuration_Table->stack_free_hook)( 10cdcb: 8b 82 c8 00 00 00 mov 0xc8(%edx),%eax <== NOT EXECUTED 10cdd1: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10cdd4: 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)( 10cdd5: ff e1 jmp *%ecx <== NOT EXECUTED 10cdd7: 90 nop <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10cdd8: c9 leave <== NOT EXECUTED 10cdd9: c3 ret <== NOT EXECUTED 10cdda: 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 ); 10cddc: 8b 82 c8 00 00 00 mov 0xc8(%edx),%eax <== NOT EXECUTED 10cde2: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10cde5: 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 ); 10cde6: e9 7d 06 00 00 jmp 10d468 <_Workspace_Free> <== NOT EXECUTED 0010ce48 <_Thread_Start>: Thread_Start_types the_prototype, void *entry_point, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10ce48: 55 push %ebp <== NOT EXECUTED 10ce49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ce4b: 53 push %ebx <== NOT EXECUTED 10ce4c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10ce4f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( _States_Is_dormant( the_thread->current_state ) ) { 10ce52: f6 43 10 01 testb $0x1,0x10(%ebx) <== NOT EXECUTED 10ce56: 75 08 jne 10ce60 <_Thread_Start+0x18> <== NOT EXECUTED 10ce58: 31 c0 xor %eax,%eax <== NOT EXECUTED return true; } return false; } 10ce5a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ce5d: c9 leave <== NOT EXECUTED 10ce5e: c3 ret <== NOT EXECUTED 10ce5f: 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; 10ce60: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10ce63: 89 83 9c 00 00 00 mov %eax,0x9c(%ebx) <== NOT EXECUTED the_thread->Start.prototype = the_prototype; 10ce69: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ce6c: 89 83 a0 00 00 00 mov %eax,0xa0(%ebx) <== NOT EXECUTED the_thread->Start.pointer_argument = pointer_argument; 10ce72: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10ce75: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) <== NOT EXECUTED the_thread->Start.numeric_argument = numeric_argument; 10ce7b: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10ce7e: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) <== NOT EXECUTED _Thread_Load_environment( the_thread ); 10ce84: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ce87: 53 push %ebx <== NOT EXECUTED 10ce88: e8 eb 2c 00 00 call 10fb78 <_Thread_Load_environment> <== NOT EXECUTED _Thread_Ready( the_thread ); 10ce8d: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10ce90: e8 67 2f 00 00 call 10fdfc <_Thread_Ready> <== NOT EXECUTED _User_extensions_Thread_start( the_thread ); 10ce95: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10ce98: e8 3f 03 00 00 call 10d1dc <_User_extensions_Thread_start> <== NOT EXECUTED 10ce9d: b0 01 mov $0x1,%al <== NOT EXECUTED 10ce9f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return true; } return false; } 10cea2: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cea5: c9 leave <== NOT EXECUTED 10cea6: c3 ret <== NOT EXECUTED 0010cdec <_Thread_Start_multitasking>: * ready chain * select heir */ void _Thread_Start_multitasking( void ) { 10cdec: 55 push %ebp <== NOT EXECUTED 10cded: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cdef: 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( 10cdf2: c7 05 84 f9 11 00 03 movl $0x3,0x11f984 <== NOT EXECUTED 10cdf9: 00 00 00 <== NOT EXECUTED * the system is shut down. */ _System_state_Set( SYSTEM_STATE_UP ); _Context_Switch_necessary = FALSE; 10cdfc: c6 05 8c f8 11 00 00 movb $0x0,0x11f88c <== NOT EXECUTED _Thread_Executing = _Thread_Heir; 10ce03: a1 48 f8 11 00 mov 0x11f848,%eax <== NOT EXECUTED 10ce08: a3 7c f8 11 00 mov %eax,0x11f87c <== 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 ) 10ce0d: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx <== NOT EXECUTED 10ce13: 85 d2 test %edx,%edx <== NOT EXECUTED 10ce15: 74 16 je 10ce2d <_Thread_Start_multitasking+0x41> <== NOT EXECUTED _Context_Restore_fp( &_Thread_Heir->fp_context ); 10ce17: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ce1a: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10ce1f: 50 push %eax <== NOT EXECUTED 10ce20: e8 39 07 00 00 call 10d55e <_CPU_Context_restore_fp> <== NOT EXECUTED 10ce25: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ce28: a1 48 f8 11 00 mov 0x11f848,%eax <== NOT EXECUTED #endif _Context_Switch( &_Thread_BSP_context, &_Thread_Heir->Registers ); 10ce2d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ce30: 05 d4 00 00 00 add $0xd4,%eax <== NOT EXECUTED 10ce35: 50 push %eax <== NOT EXECUTED 10ce36: 68 a0 f7 11 00 push $0x11f7a0 <== NOT EXECUTED 10ce3b: e8 e0 06 00 00 call 10d520 <_CPU_Context_switch> <== NOT EXECUTED 10ce40: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10ce43: c9 leave <== NOT EXECUTED 10ce44: c3 ret <== NOT EXECUTED 0010e450 <_Thread_Suspend>: */ void _Thread_Suspend( Thread_Control *the_thread ) { 10e450: 55 push %ebp <== NOT EXECUTED 10e451: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e453: 56 push %esi <== NOT EXECUTED 10e454: 53 push %ebx <== NOT EXECUTED 10e455: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Chain_Control *ready; ready = the_thread->ready; 10e458: 8b 91 8c 00 00 00 mov 0x8c(%ecx),%edx <== NOT EXECUTED _ISR_Disable( level ); 10e45e: 9c pushf <== NOT EXECUTED 10e45f: fa cli <== NOT EXECUTED 10e460: 5b pop %ebx <== NOT EXECUTED the_thread->suspend_count++; 10e461: ff 41 70 incl 0x70(%ecx) <== NOT EXECUTED if ( !_States_Is_ready( the_thread->current_state ) ) { 10e464: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED 10e467: 85 c0 test %eax,%eax <== NOT EXECUTED 10e469: 75 31 jne 10e49c <_Thread_Suspend+0x4c> <== NOT EXECUTED _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); return; } the_thread->current_state = STATES_SUSPENDED; 10e46b: c7 41 10 02 00 00 00 movl $0x2,0x10(%ecx) <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10e472: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10e474: 3b 42 08 cmp 0x8(%edx),%eax <== NOT EXECUTED 10e477: 74 2f je 10e4a8 <_Thread_Suspend+0x58> <== NOT EXECUTED 10e479: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10e47b: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10e47e: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10e481: 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 ); 10e483: 53 push %ebx <== NOT EXECUTED 10e484: 9d popf <== NOT EXECUTED 10e485: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) 10e486: 3b 0d 68 b8 12 00 cmp 0x12b868,%ecx <== NOT EXECUTED 10e48c: 74 62 je 10e4f0 <_Thread_Suspend+0xa0> <== NOT EXECUTED _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) 10e48e: 3b 0d 9c b8 12 00 cmp 0x12b89c,%ecx <== NOT EXECUTED 10e494: 74 4e je 10e4e4 <_Thread_Suspend+0x94> <== NOT EXECUTED _Context_Switch_necessary = TRUE; _ISR_Enable( level ); 10e496: 53 push %ebx <== NOT EXECUTED 10e497: 9d popf <== NOT EXECUTED } 10e498: 5b pop %ebx <== NOT EXECUTED 10e499: 5e pop %esi <== NOT EXECUTED 10e49a: c9 leave <== NOT EXECUTED 10e49b: 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 = 10e49c: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 10e49f: 89 41 10 mov %eax,0x10(%ecx) <== NOT EXECUTED _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); 10e4a2: 53 push %ebx <== NOT EXECUTED 10e4a3: 9d popf <== NOT EXECUTED if ( _Thread_Is_executing( the_thread ) ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10e4a4: 5b pop %ebx <== NOT EXECUTED 10e4a5: 5e pop %esi <== NOT EXECUTED 10e4a6: c9 leave <== NOT EXECUTED 10e4a7: c3 ret <== NOT EXECUTED 10e4a8: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10e4ab: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10e4ad: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10e4b4: 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 10e4b7: 8b 81 90 00 00 00 mov 0x90(%ecx),%eax <== NOT EXECUTED 10e4bd: 66 8b 91 9a 00 00 00 mov 0x9a(%ecx),%dx <== NOT EXECUTED 10e4c4: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10e4c7: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10e4cb: 75 b6 jne 10e483 <_Thread_Suspend+0x33> <== NOT EXECUTED * to be resized 10e4cd: 66 a1 90 b8 12 00 mov 0x12b890,%ax <== NOT EXECUTED 10e4d3: 23 81 98 00 00 00 and 0x98(%ecx),%eax <== NOT EXECUTED 10e4d9: 66 a3 90 b8 12 00 mov %ax,0x12b890 <== NOT EXECUTED 10e4df: eb a2 jmp 10e483 <_Thread_Suspend+0x33> <== NOT EXECUTED 10e4e1: 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; 10e4e4: c6 05 ac b8 12 00 01 movb $0x1,0x12b8ac <== NOT EXECUTED 10e4eb: eb a9 jmp 10e496 <_Thread_Suspend+0x46> <== NOT EXECUTED 10e4ed: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10e4f0: 66 8b 35 90 b8 12 00 mov 0x12b890,%si <== NOT EXECUTED 10e4f7: 31 d2 xor %edx,%edx <== NOT EXECUTED 10e4f9: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e4fb: 66 0f bc c6 bsf %si,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10e4ff: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10e502: 66 8b b4 00 20 b9 12 mov 0x12b920(%eax,%eax,1),%si <== NOT EXECUTED 10e509: 00 <== NOT EXECUTED 10e50a: 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. 10e50e: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10e511: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10e514: 01 d0 add %edx,%eax <== NOT EXECUTED 10e516: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10e519: 8b 15 a0 b7 12 00 mov 0x12b7a0,%edx <== NOT EXECUTED 10e51f: 8b 04 82 mov (%edx,%eax,4),%eax <== NOT EXECUTED 10e522: a3 68 b8 12 00 mov %eax,0x12b868 <== NOT EXECUTED 10e527: e9 62 ff ff ff jmp 10e48e <_Thread_Suspend+0x3e> <== NOT EXECUTED 0010cea8 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10cea8: 55 push %ebp <== NOT EXECUTED 10cea9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ceab: 53 push %ebx <== NOT EXECUTED 10ceac: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 10ceaf: 8b 1d 7c f8 11 00 mov 0x11f87c,%ebx <== NOT EXECUTED /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10ceb5: 80 7b 76 00 cmpb $0x0,0x76(%ebx) <== NOT EXECUTED 10ceb9: 74 19 je 10ced4 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED return; if ( !_States_Is_ready( executing->current_state ) ) 10cebb: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10cebe: 85 c0 test %eax,%eax <== NOT EXECUTED 10cec0: 75 12 jne 10ced4 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10cec2: 8b 43 7c mov 0x7c(%ebx),%eax <== NOT EXECUTED 10cec5: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10cec8: 72 0a jb 10ced4 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED 10ceca: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10cecd: 76 29 jbe 10cef8 <_Thread_Tickle_timeslice+0x50> <== NOT EXECUTED 10cecf: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10ced2: 74 08 je 10cedc <_Thread_Tickle_timeslice+0x34> <== NOT EXECUTED case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) (*executing->budget_callout)( executing ); break; } } 10ced4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ced7: c9 leave <== NOT EXECUTED 10ced8: c3 ret <== NOT EXECUTED 10ced9: 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 ) 10cedc: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 10cedf: 48 dec %eax <== NOT EXECUTED 10cee0: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10cee3: 85 c0 test %eax,%eax <== NOT EXECUTED 10cee5: 75 ed jne 10ced4 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED (*executing->budget_callout)( executing ); 10cee7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ceea: 53 push %ebx <== NOT EXECUTED 10ceeb: ff 93 80 00 00 00 call *0x80(%ebx) <== NOT EXECUTED 10cef1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cef4: eb de jmp 10ced4 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED 10cef6: 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 ) { 10cef8: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 10cefb: 48 dec %eax <== NOT EXECUTED 10cefc: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10ceff: 85 c0 test %eax,%eax <== NOT EXECUTED 10cf01: 7f d1 jg 10ced4 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED _Thread_Reset_timeslice(); 10cf03: e8 94 2f 00 00 call 10fe9c <_Thread_Reset_timeslice> <== NOT EXECUTED executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10cf08: a1 84 f7 11 00 mov 0x11f784,%eax <== NOT EXECUTED 10cf0d: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10cf10: eb c2 jmp 10ced4 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED 0010cf14 <_Thread_Yield_processor>: * ready chain * select heir */ void _Thread_Yield_processor( void ) { 10cf14: 55 push %ebp <== NOT EXECUTED 10cf15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cf17: 56 push %esi <== NOT EXECUTED 10cf18: 53 push %ebx <== NOT EXECUTED ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10cf19: 8b 0d 7c f8 11 00 mov 0x11f87c,%ecx <== NOT EXECUTED ready = executing->ready; 10cf1f: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx <== NOT EXECUTED _ISR_Disable( level ); 10cf25: 9c pushf <== NOT EXECUTED 10cf26: fa cli <== NOT EXECUTED 10cf27: 5e pop %esi <== NOT EXECUTED if ( !_Chain_Has_only_one_node( ready ) ) { 10cf28: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10cf2a: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10cf2d: 74 35 je 10cf64 <_Thread_Yield_processor+0x50> <== NOT EXECUTED 10cf2f: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10cf31: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10cf34: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10cf37: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10cf39: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 10cf3c: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10cf3e: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10cf41: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED 10cf44: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10cf46: 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 ); 10cf49: 56 push %esi <== NOT EXECUTED 10cf4a: 9d popf <== NOT EXECUTED 10cf4b: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( executing ) ) 10cf4c: 3b 0d 48 f8 11 00 cmp 0x11f848,%ecx <== NOT EXECUTED 10cf52: 74 1c je 10cf70 <_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; 10cf54: c6 05 8c f8 11 00 01 movb $0x1,0x11f88c <== NOT EXECUTED _ISR_Enable( level ); 10cf5b: 56 push %esi <== NOT EXECUTED 10cf5c: 9d popf <== NOT EXECUTED } 10cf5d: 5b pop %ebx <== NOT EXECUTED 10cf5e: 5e pop %esi <== NOT EXECUTED 10cf5f: c9 leave <== NOT EXECUTED 10cf60: c3 ret <== NOT EXECUTED 10cf61: 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 ) ) 10cf64: 3b 0d 48 f8 11 00 cmp 0x11f848,%ecx <== NOT EXECUTED 10cf6a: 75 e8 jne 10cf54 <_Thread_Yield_processor+0x40> <== NOT EXECUTED 10cf6c: eb ed jmp 10cf5b <_Thread_Yield_processor+0x47> <== NOT EXECUTED 10cf6e: 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; 10cf70: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10cf72: a3 48 f8 11 00 mov %eax,0x11f848 <== NOT EXECUTED 10cf77: eb db jmp 10cf54 <_Thread_Yield_processor+0x40> <== NOT EXECUTED 0010be24 <_Thread_blocking_operation_Cancel>: void _Thread_blocking_operation_Cancel( Thread_blocking_operation_States sync_state, Thread_Control *the_thread, ISR_Level level ) { 10be24: 55 push %ebp <== NOT EXECUTED 10be25: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10be27: 53 push %ebx <== NOT EXECUTED 10be28: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10be2b: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10be2e: 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; 10be31: 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 ) ) { 10be38: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10be3c: 74 16 je 10be54 <_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 ); 10be3e: 50 push %eax <== NOT EXECUTED 10be3f: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10be40: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 10be47: 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 } 10be4a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10be4d: c9 leave <== NOT EXECUTED 10be4e: e9 51 01 00 00 jmp 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 10be53: 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 */ 10be54: 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 ); 10be5b: 50 push %eax <== NOT EXECUTED 10be5c: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10be5d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10be60: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10be63: 50 push %eax <== NOT EXECUTED 10be64: e8 23 15 00 00 call 10d38c <_Watchdog_Remove> <== NOT EXECUTED 10be69: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10be6c: eb d2 jmp 10be40 <_Thread_blocking_operation_Cancel+0x1c> <== NOT EXECUTED 0010c6d0 <_Thread_queue_Dequeue>: */ Thread_Control *_Thread_queue_Dequeue( Thread_queue_Control *the_thread_queue ) { 10c6d0: 55 push %ebp <== NOT EXECUTED 10c6d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c6d3: 53 push %ebx <== NOT EXECUTED 10c6d4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10c6d7: 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 ) 10c6da: 83 7b 34 01 cmpl $0x1,0x34(%ebx) <== NOT EXECUTED 10c6de: 74 20 je 10c700 <_Thread_queue_Dequeue+0x30> <== NOT EXECUTED 10c6e0: b8 00 fc 10 00 mov $0x10fc00,%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 ); 10c6e5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c6e8: 53 push %ebx <== NOT EXECUTED 10c6e9: ff d0 call *%eax <== NOT EXECUTED 10c6eb: 89 c2 mov %eax,%edx <== NOT EXECUTED _ISR_Disable( level ); 10c6ed: 9c pushf <== NOT EXECUTED 10c6ee: fa cli <== NOT EXECUTED 10c6ef: 59 pop %ecx <== NOT EXECUTED if ( !the_thread ) { 10c6f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c6f3: 85 c0 test %eax,%eax <== NOT EXECUTED 10c6f5: 74 11 je 10c708 <_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 ); 10c6f7: 51 push %ecx <== NOT EXECUTED 10c6f8: 9d popf <== NOT EXECUTED return the_thread; } 10c6f9: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c6fb: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c6fe: c9 leave <== NOT EXECUTED 10c6ff: 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 ) 10c700: b8 20 c7 10 00 mov $0x10c720,%eax <== NOT EXECUTED 10c705: eb de jmp 10c6e5 <_Thread_queue_Dequeue+0x15> <== NOT EXECUTED 10c707: 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) || 10c708: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10c70b: 48 dec %eax <== NOT EXECUTED 10c70c: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10c70f: 77 e6 ja 10c6f7 <_Thread_queue_Dequeue+0x27> <== NOT EXECUTED (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 10c711: c7 43 30 03 00 00 00 movl $0x3,0x30(%ebx) <== NOT EXECUTED the_thread = _Thread_Executing; 10c718: 8b 15 7c f8 11 00 mov 0x11f87c,%edx <== NOT EXECUTED 10c71e: eb d7 jmp 10c6f7 <_Thread_queue_Dequeue+0x27> <== NOT EXECUTED 0010fc00 <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 10fc00: 55 push %ebp <== NOT EXECUTED 10fc01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fc03: 56 push %esi <== NOT EXECUTED 10fc04: 53 push %ebx <== NOT EXECUTED 10fc05: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); 10fc08: 9c pushf <== NOT EXECUTED 10fc09: fa cli <== NOT EXECUTED 10fc0a: 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( 10fc0b: 8b 11 mov (%ecx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 10fc0d: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10fc10: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10fc12: 74 62 je 10fc76 <_Thread_queue_Dequeue_fifo+0x76> <== NOT EXECUTED 10fc14: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10fc16: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10fc18: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED the_thread = (Thread_Control *) 10fc1b: 89 d3 mov %edx,%ebx <== NOT EXECUTED _Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo ); the_thread->Wait.queue = NULL; 10fc1d: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10fc24: 83 7a 50 02 cmpl $0x2,0x50(%edx) <== NOT EXECUTED 10fc28: 74 1e je 10fc48 <_Thread_queue_Dequeue_fifo+0x48> <== NOT EXECUTED _ISR_Enable( level ); 10fc2a: 56 push %esi <== NOT EXECUTED 10fc2b: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10fc2c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10fc2f: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10fc34: 52 push %edx <== NOT EXECUTED 10fc35: e8 6a c3 ff ff call 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 10fc3a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return the_thread; } _ISR_Enable( level ); return NULL; } 10fc3d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10fc3f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10fc42: 5b pop %ebx <== NOT EXECUTED 10fc43: 5e pop %esi <== NOT EXECUTED 10fc44: c9 leave <== NOT EXECUTED 10fc45: c3 ret <== NOT EXECUTED 10fc46: 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 */ 10fc48: 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 ); 10fc4f: 56 push %esi <== NOT EXECUTED 10fc50: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10fc51: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fc54: 8d 42 48 lea 0x48(%edx),%eax <== NOT EXECUTED 10fc57: 50 push %eax <== NOT EXECUTED 10fc58: e8 2f d7 ff ff call 10d38c <_Watchdog_Remove> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10fc5d: 58 pop %eax <== NOT EXECUTED 10fc5e: 5a pop %edx <== NOT EXECUTED 10fc5f: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10fc64: 53 push %ebx <== NOT EXECUTED 10fc65: e8 3a c3 ff ff call 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 10fc6a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return the_thread; } _ISR_Enable( level ); return NULL; } 10fc6d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10fc6f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10fc72: 5b pop %ebx <== NOT EXECUTED 10fc73: 5e pop %esi <== NOT EXECUTED 10fc74: c9 leave <== NOT EXECUTED 10fc75: c3 ret <== NOT EXECUTED #endif return the_thread; } _ISR_Enable( level ); 10fc76: 56 push %esi <== NOT EXECUTED 10fc77: 9d popf <== NOT EXECUTED 10fc78: 31 db xor %ebx,%ebx <== NOT EXECUTED 10fc7a: eb c1 jmp 10fc3d <_Thread_queue_Dequeue_fifo+0x3d> <== NOT EXECUTED 0010c720 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 10c720: 55 push %ebp <== NOT EXECUTED 10c721: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c723: 57 push %edi <== NOT EXECUTED 10c724: 56 push %esi <== NOT EXECUTED 10c725: 53 push %ebx <== NOT EXECUTED 10c726: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c729: 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 ); 10c72c: 9c pushf <== NOT EXECUTED 10c72d: fa cli <== NOT EXECUTED 10c72e: 5f pop %edi <== NOT EXECUTED 10c72f: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c731: 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( 10c733: 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 ] ) ) { 10c736: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10c739: 8d 44 86 04 lea 0x4(%esi,%eax,4),%eax <== NOT EXECUTED 10c73d: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10c73f: 75 1f jne 10c760 <_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++ ) { 10c741: 42 inc %edx <== NOT EXECUTED 10c742: 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 ; 10c745: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10c748: 75 e9 jne 10c733 <_Thread_queue_Dequeue_priority+0x13> <== NOT EXECUTED } /* * We did not find a thread to unblock. */ _ISR_Enable( level ); 10c74a: 57 push %edi <== NOT EXECUTED 10c74b: 9d popf <== NOT EXECUTED 10c74c: 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 ); } 10c753: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10c756: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c759: 5b pop %ebx <== NOT EXECUTED 10c75a: 5e pop %esi <== NOT EXECUTED 10c75b: 5f pop %edi <== NOT EXECUTED 10c75c: c9 leave <== NOT EXECUTED 10c75d: c3 ret <== NOT EXECUTED 10c75e: 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 *) 10c760: 89 5d e8 mov %ebx,-0x18(%ebp) <== NOT EXECUTED */ _ISR_Enable( level ); return NULL; dequeue: the_thread->Wait.queue = NULL; 10c763: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED new_first_node = the_thread->Wait.Block2n.first; 10c76a: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; 10c76d: 8b 33 mov (%ebx),%esi <== NOT EXECUTED previous_node = the_thread->Object.Node.previous; 10c76f: 8b 4b 04 mov 0x4(%ebx),%ecx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10c772: 8d 43 3c lea 0x3c(%ebx),%eax <== NOT EXECUTED 10c775: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10c777: 0f 84 85 00 00 00 je 10c802 <_Thread_queue_Dequeue_priority+0xe2> <== NOT EXECUTED last_node = the_thread->Wait.Block2n.last; 10c77d: 8b 43 40 mov 0x40(%ebx),%eax <== NOT EXECUTED 10c780: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED new_second_node = new_first_node->next; 10c783: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10c785: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED previous_node->next = new_first_node; 10c788: 89 11 mov %edx,(%ecx) <== NOT EXECUTED next_node->previous = new_first_node; 10c78a: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED new_first_node->next = next_node; 10c78d: 89 32 mov %esi,(%edx) <== NOT EXECUTED new_first_node->previous = previous_node; 10c78f: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10c792: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10c795: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 10c798: 74 1a je 10c7b4 <_Thread_queue_Dequeue_priority+0x94> <== NOT EXECUTED /* > two threads on 2-n */ new_second_node->previous = 10c79a: 8d 42 38 lea 0x38(%edx),%eax <== NOT EXECUTED 10c79d: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 10c7a0: 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; 10c7a3: 89 4a 38 mov %ecx,0x38(%edx) <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 10c7a6: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10c7a9: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10c7ac: 8d 42 3c lea 0x3c(%edx),%eax <== NOT EXECUTED 10c7af: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10c7b2: 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 ) ) { 10c7b4: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10c7b8: 74 1e je 10c7d8 <_Thread_queue_Dequeue_priority+0xb8> <== NOT EXECUTED _ISR_Enable( level ); 10c7ba: 57 push %edi <== NOT EXECUTED 10c7bb: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10c7bc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c7bf: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10c7c4: 53 push %ebx <== NOT EXECUTED 10c7c5: e8 da f7 ff ff call 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 10c7ca: 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 ); } 10c7cd: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10c7d0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c7d3: 5b pop %ebx <== NOT EXECUTED 10c7d4: 5e pop %esi <== NOT EXECUTED 10c7d5: 5f pop %edi <== NOT EXECUTED 10c7d6: c9 leave <== NOT EXECUTED 10c7d7: 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 */ 10c7d8: 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 ); 10c7df: 57 push %edi <== NOT EXECUTED 10c7e0: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10c7e1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c7e4: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10c7e7: 50 push %eax <== NOT EXECUTED 10c7e8: e8 9f 0b 00 00 call 10d38c <_Watchdog_Remove> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10c7ed: 58 pop %eax <== NOT EXECUTED 10c7ee: 5a pop %edx <== NOT EXECUTED 10c7ef: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10c7f4: 53 push %ebx <== NOT EXECUTED 10c7f5: e8 aa f7 ff ff call 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 10c7fa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c7fd: e9 51 ff ff ff jmp 10c753 <_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; 10c802: 89 31 mov %esi,(%ecx) <== NOT EXECUTED next_node->previous = previous_node; 10c804: 89 4e 04 mov %ecx,0x4(%esi) <== NOT EXECUTED 10c807: eb ab jmp 10c7b4 <_Thread_queue_Dequeue_priority+0x94> <== NOT EXECUTED 0010fc7c <_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 ) { 10fc7c: 55 push %ebp <== NOT EXECUTED 10fc7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fc7f: 56 push %esi <== NOT EXECUTED 10fc80: 53 push %ebx <== NOT EXECUTED 10fc81: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10fc84: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Thread_blocking_operation_States sync_state; ISR_Level level; _ISR_Disable( level ); 10fc87: 9c pushf <== NOT EXECUTED 10fc88: fa cli <== NOT EXECUTED 10fc89: 5e pop %esi <== NOT EXECUTED sync_state = the_thread_queue->sync_state; 10fc8a: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10fc8d: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) <== NOT EXECUTED if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) { 10fc94: 83 f9 01 cmp $0x1,%ecx <== NOT EXECUTED 10fc97: 74 0b je 10fca4 <_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; 10fc99: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10fc9c: 89 30 mov %esi,(%eax) <== NOT EXECUTED return sync_state; } 10fc9e: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10fca0: 5b pop %ebx <== NOT EXECUTED 10fca1: 5e pop %esi <== NOT EXECUTED 10fca2: c9 leave <== NOT EXECUTED 10fca3: c3 ret <== NOT EXECUTED 10fca4: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10fca7: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10fca9: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10fcac: 89 5a 08 mov %ebx,0x8(%edx) <== NOT EXECUTED 10fcaf: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10fcb1: 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; 10fcb4: 89 53 44 mov %edx,0x44(%ebx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; _ISR_Enable( level ); 10fcb7: 56 push %esi <== NOT EXECUTED 10fcb8: 9d popf <== NOT EXECUTED * * WARNING! Returning with interrupts disabled! */ *level_p = level; return sync_state; } 10fcb9: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10fcbb: 5b pop %ebx <== NOT EXECUTED 10fcbc: 5e pop %esi <== NOT EXECUTED 10fcbd: c9 leave <== NOT EXECUTED 10fcbe: c3 ret <== NOT EXECUTED 0010c8a4 <_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 ) { 10c8a4: 55 push %ebp <== NOT EXECUTED 10c8a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c8a7: 57 push %edi <== NOT EXECUTED 10c8a8: 56 push %esi <== NOT EXECUTED 10c8a9: 53 push %ebx <== NOT EXECUTED 10c8aa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c8ad: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c8b0: 83 c0 3c add $0x3c,%eax <== NOT EXECUTED 10c8b3: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10c8b6: 89 42 38 mov %eax,0x38(%edx) <== NOT EXECUTED 10c8b9: c7 42 3c 00 00 00 00 movl $0x0,0x3c(%edx) <== NOT EXECUTED 10c8c0: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c8c2: 83 c0 38 add $0x38,%eax <== NOT EXECUTED 10c8c5: 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; 10c8c8: 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. 10c8cb: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c8cd: 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; 10c8d0: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c8d3: 8b 49 38 mov 0x38(%ecx),%ecx <== NOT EXECUTED 10c8d6: 89 4d f0 mov %ecx,-0x10(%ebp) <== NOT EXECUTED if ( _Thread_queue_Is_reverse_search( priority ) ) 10c8d9: f6 c3 20 test $0x20,%bl <== NOT EXECUTED 10c8dc: 75 66 jne 10c944 <_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 10c8de: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10c8e1: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10c8e4: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c8e7: 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; 10c8eb: 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 ); 10c8ee: 9c pushf <== NOT EXECUTED 10c8ef: fa cli <== NOT EXECUTED 10c8f0: 5e pop %esi <== NOT EXECUTED search_thread = (Thread_Control *) header->first; 10c8f1: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10c8f4: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c8f7: 8b 14 08 mov (%eax,%ecx,1),%edx <== NOT EXECUTED while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10c8fa: 39 fa cmp %edi,%edx <== NOT EXECUTED 10c8fc: 75 1b jne 10c919 <_Thread_queue_Enqueue_priority+0x75> <== NOT EXECUTED 10c8fe: e9 1a 01 00 00 jmp 10ca1d <_Thread_queue_Enqueue_priority+0x179> <== NOT EXECUTED 10c903: 90 nop <== NOT EXECUTED break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10c904: 56 push %esi <== NOT EXECUTED 10c905: 9d popf <== NOT EXECUTED 10c906: fa cli <== NOT EXECUTED if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c907: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10c90a: 85 42 10 test %eax,0x10(%edx) <== NOT EXECUTED 10c90d: 0f 84 ad 00 00 00 je 10c9c0 <_Thread_queue_Enqueue_priority+0x11c> <== NOT EXECUTED _ISR_Enable( level ); goto restart_forward_search; } search_thread = 10c913: 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 ) ) { 10c915: 39 fa cmp %edi,%edx <== NOT EXECUTED 10c917: 74 07 je 10c920 <_Thread_queue_Enqueue_priority+0x7c> <== NOT EXECUTED search_priority = search_thread->current_priority; 10c919: 8b 4a 14 mov 0x14(%edx),%ecx <== NOT EXECUTED if ( priority <= search_priority ) 10c91c: 39 cb cmp %ecx,%ebx <== NOT EXECUTED 10c91e: 77 e4 ja 10c904 <_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 ) ) { 10c920: 89 d7 mov %edx,%edi <== NOT EXECUTED } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10c922: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c925: 83 78 30 01 cmpl $0x1,0x30(%eax) <== NOT EXECUTED 10c929: 0f 84 99 00 00 00 je 10c9c8 <_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; 10c92f: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10c932: 89 30 mov %esi,(%eax) <== NOT EXECUTED return the_thread_queue->sync_state; 10c934: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c937: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED } 10c93a: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c93d: 5b pop %ebx <== NOT EXECUTED 10c93e: 5e pop %esi <== NOT EXECUTED 10c93f: 5f pop %edi <== NOT EXECUTED 10c940: c9 leave <== NOT EXECUTED 10c941: c3 ret <== NOT EXECUTED 10c942: 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; 10c944: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10c947: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c94a: 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; 10c94d: 8d 79 08 lea 0x8(%ecx),%edi <== NOT EXECUTED 10c950: 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; 10c953: 0f b6 05 d4 b1 11 00 movzbl 0x11b1d4,%eax <== NOT EXECUTED 10c95a: 40 inc %eax <== NOT EXECUTED _ISR_Disable( level ); 10c95b: 9c pushf <== NOT EXECUTED 10c95c: fa cli <== NOT EXECUTED 10c95d: 5e pop %esi <== NOT EXECUTED search_thread = (Thread_Control *) header->last; 10c95e: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 10c961: 8b 17 mov (%edi),%edx <== NOT EXECUTED while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10c963: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 10c965: 75 17 jne 10c97e <_Thread_queue_Enqueue_priority+0xda> <== NOT EXECUTED 10c967: eb 1c jmp 10c985 <_Thread_queue_Enqueue_priority+0xe1> <== NOT EXECUTED 10c969: 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 ); 10c96c: 56 push %esi <== NOT EXECUTED 10c96d: 9d popf <== NOT EXECUTED 10c96e: fa cli <== NOT EXECUTED if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c96f: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 10c972: 85 7a 10 test %edi,0x10(%edx) <== NOT EXECUTED 10c975: 74 45 je 10c9bc <_Thread_queue_Enqueue_priority+0x118> <== NOT EXECUTED _ISR_Enable( level ); goto restart_reverse_search; } search_thread = (Thread_Control *) 10c977: 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 ) ) { 10c97a: 39 ca cmp %ecx,%edx <== NOT EXECUTED 10c97c: 74 07 je 10c985 <_Thread_queue_Enqueue_priority+0xe1> <== NOT EXECUTED search_priority = search_thread->current_priority; 10c97e: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED if ( priority >= search_priority ) 10c981: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10c983: 72 e7 jb 10c96c <_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 ) ) { 10c985: 89 d7 mov %edx,%edi <== NOT EXECUTED } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10c987: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c98a: 83 79 30 01 cmpl $0x1,0x30(%ecx) <== NOT EXECUTED 10c98e: 75 9f jne 10c92f <_Thread_queue_Enqueue_priority+0x8b> <== NOT EXECUTED THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c990: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) <== NOT EXECUTED if ( priority == search_priority ) 10c997: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10c999: 74 5d je 10c9f8 <_Thread_queue_Enqueue_priority+0x154> <== NOT EXECUTED goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10c99b: 8b 02 mov (%edx),%eax <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10c99d: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10c9a0: 89 07 mov %eax,(%edi) <== NOT EXECUTED the_node->previous = search_node; 10c9a2: 89 57 04 mov %edx,0x4(%edi) <== NOT EXECUTED search_node->next = the_node; 10c9a5: 89 3a mov %edi,(%edx) <== NOT EXECUTED next_node->previous = the_node; 10c9a7: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10c9aa: 89 4f 44 mov %ecx,0x44(%edi) <== NOT EXECUTED _ISR_Enable( level ); 10c9ad: 56 push %esi <== NOT EXECUTED 10c9ae: 9d popf <== NOT EXECUTED 10c9af: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10c9b4: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c9b7: 5b pop %ebx <== NOT EXECUTED 10c9b8: 5e pop %esi <== NOT EXECUTED 10c9b9: 5f pop %edi <== NOT EXECUTED 10c9ba: c9 leave <== NOT EXECUTED 10c9bb: 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 ); 10c9bc: 56 push %esi <== NOT EXECUTED 10c9bd: 9d popf <== NOT EXECUTED 10c9be: eb 93 jmp 10c953 <_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 ); 10c9c0: 56 push %esi <== NOT EXECUTED 10c9c1: 9d popf <== NOT EXECUTED 10c9c2: e9 27 ff ff ff jmp 10c8ee <_Thread_queue_Enqueue_priority+0x4a> <== NOT EXECUTED 10c9c7: 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; 10c9c8: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) <== NOT EXECUTED if ( priority == search_priority ) 10c9cf: 39 cb cmp %ecx,%ebx <== NOT EXECUTED 10c9d1: 74 25 je 10c9f8 <_Thread_queue_Enqueue_priority+0x154> <== NOT EXECUTED goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10c9d3: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c9d6: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10c9d9: 89 11 mov %edx,(%ecx) <== NOT EXECUTED the_node->previous = previous_node; 10c9db: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED previous_node->next = the_node; 10c9de: 89 08 mov %ecx,(%eax) <== NOT EXECUTED search_node->previous = the_node; 10c9e0: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10c9e3: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10c9e6: 89 79 44 mov %edi,0x44(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10c9e9: 56 push %esi <== NOT EXECUTED 10c9ea: 9d popf <== NOT EXECUTED 10c9eb: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10c9f0: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c9f3: 5b pop %ebx <== NOT EXECUTED 10c9f4: 5e pop %esi <== NOT EXECUTED 10c9f5: 5f pop %edi <== NOT EXECUTED 10c9f6: c9 leave <== NOT EXECUTED 10c9f7: c3 ret <== NOT EXECUTED 10c9f8: 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; 10c9fb: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c9fe: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10ca01: 89 01 mov %eax,(%ecx) <== NOT EXECUTED the_node->previous = previous_node; 10ca03: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED previous_node->next = the_node; 10ca06: 89 0a mov %ecx,(%edx) <== NOT EXECUTED search_node->previous = the_node; 10ca08: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10ca0b: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10ca0e: 89 79 44 mov %edi,0x44(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10ca11: 56 push %esi <== NOT EXECUTED 10ca12: 9d popf <== NOT EXECUTED 10ca13: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10ca18: e9 1d ff ff ff jmp 10c93a <_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 ) ) { 10ca1d: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 10ca22: e9 fb fe ff ff jmp 10c922 <_Thread_queue_Enqueue_priority+0x7e> <== NOT EXECUTED 0010c80c <_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 ) { 10c80c: 55 push %ebp <== NOT EXECUTED 10c80d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c80f: 57 push %edi <== NOT EXECUTED 10c810: 56 push %esi <== NOT EXECUTED 10c811: 53 push %ebx <== NOT EXECUTED 10c812: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 10c815: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10c818: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Thread_queue_Control *, Thread_Control *, ISR_Level * ); the_thread = _Thread_Executing; 10c81b: 8b 1d 7c f8 11 00 mov 0x11f87c,%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 ); 10c821: ff 76 38 pushl 0x38(%esi) <== NOT EXECUTED 10c824: 53 push %ebx <== NOT EXECUTED 10c825: e8 d6 03 00 00 call 10cc00 <_Thread_Set_state> <== NOT EXECUTED /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { 10c82a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c82d: 85 ff test %edi,%edi <== NOT EXECUTED 10c82f: 75 33 jne 10c864 <_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 ) 10c831: 83 7e 34 01 cmpl $0x1,0x34(%esi) <== NOT EXECUTED 10c835: 74 64 je 10c89b <_Thread_queue_Enqueue_with_handler+0x8f> <== NOT EXECUTED 10c837: ba 7c fc 10 00 mov $0x10fc7c,%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 ); 10c83c: 51 push %ecx <== NOT EXECUTED 10c83d: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10c840: 50 push %eax <== NOT EXECUTED 10c841: 53 push %ebx <== NOT EXECUTED 10c842: 56 push %esi <== NOT EXECUTED 10c843: ff d2 call *%edx <== NOT EXECUTED if ( sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 10c845: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c848: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10c84b: 74 0e je 10c85b <_Thread_queue_Enqueue_with_handler+0x4f> <== NOT EXECUTED _Thread_blocking_operation_Cancel( sync_state, the_thread, level ); 10c84d: 52 push %edx <== NOT EXECUTED 10c84e: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10c851: 53 push %ebx <== NOT EXECUTED 10c852: 50 push %eax <== NOT EXECUTED 10c853: e8 cc f5 ff ff call 10be24 <_Thread_blocking_operation_Cancel> <== NOT EXECUTED 10c858: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10c85b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c85e: 5b pop %ebx <== NOT EXECUTED 10c85f: 5e pop %esi <== NOT EXECUTED 10c860: 5f pop %edi <== NOT EXECUTED 10c861: c9 leave <== NOT EXECUTED 10c862: c3 ret <== NOT EXECUTED 10c863: 90 nop <== NOT EXECUTED /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { _Watchdog_Initialize( 10c864: 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. * 10c867: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10c86e: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10c871: 89 53 64 mov %edx,0x64(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10c874: 89 43 68 mov %eax,0x68(%ebx) <== NOT EXECUTED * the heap 10c877: 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, 10c87e: 89 7b 54 mov %edi,0x54(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10c881: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c884: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10c887: 50 push %eax <== NOT EXECUTED 10c888: 68 9c f8 11 00 push $0x11f89c <== NOT EXECUTED 10c88d: e8 ca 09 00 00 call 10d25c <_Watchdog_Insert> <== NOT EXECUTED 10c892: 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 ) 10c895: 83 7e 34 01 cmpl $0x1,0x34(%esi) <== NOT EXECUTED 10c899: 75 9c jne 10c837 <_Thread_queue_Enqueue_with_handler+0x2b> <== NOT EXECUTED 10c89b: ba a4 c8 10 00 mov $0x10c8a4,%edx <== NOT EXECUTED 10c8a0: eb 9a jmp 10c83c <_Thread_queue_Enqueue_with_handler+0x30> <== NOT EXECUTED 0010fcc0 <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10fcc0: 55 push %ebp <== NOT EXECUTED 10fcc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fcc3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10fcc6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10fcc9: 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 ) 10fccc: 83 78 34 01 cmpl $0x1,0x34(%eax) <== NOT EXECUTED 10fcd0: 74 0e je 10fce0 <_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 ); 10fcd2: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 10fcd5: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10fcd8: 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 ); 10fcd9: e9 96 0e 00 00 jmp 110b74 <_Thread_queue_Extract_fifo> <== NOT EXECUTED 10fcde: 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 ); 10fce0: 51 push %ecx <== NOT EXECUTED 10fce1: 6a 00 push $0x0 <== NOT EXECUTED 10fce3: 52 push %edx <== NOT EXECUTED 10fce4: 50 push %eax <== NOT EXECUTED 10fce5: e8 06 00 00 00 call 10fcf0 <_Thread_queue_Extract_priority_helper> <== NOT EXECUTED 10fcea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); } 10fced: c9 leave <== NOT EXECUTED 10fcee: c3 ret <== NOT EXECUTED 00110b74 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 110b74: 55 push %ebp <== NOT EXECUTED 110b75: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110b77: 53 push %ebx <== NOT EXECUTED 110b78: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 110b7b: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 110b7e: 9c pushf <== NOT EXECUTED 110b7f: fa cli <== NOT EXECUTED 110b80: 59 pop %ecx <== NOT EXECUTED if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 110b81: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) <== NOT EXECUTED 110b88: 74 2e je 110bb8 <_Thread_queue_Extract_fifo+0x44> <== NOT EXECUTED 110b8a: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 110b8c: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 110b8f: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 110b92: 89 10 mov %edx,(%eax) <== NOT EXECUTED return; } _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; 110b94: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 110b9b: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 110b9f: 74 1f je 110bc0 <_Thread_queue_Extract_fifo+0x4c> <== NOT EXECUTED _ISR_Enable( level ); 110ba1: 51 push %ecx <== NOT EXECUTED 110ba2: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 110ba3: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 110baa: 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 } 110bad: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110bb0: c9 leave <== NOT EXECUTED 110bb1: e9 ee b3 ff ff jmp 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 110bb6: 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 ); 110bb8: 51 push %ecx <== NOT EXECUTED 110bb9: 9d popf <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 110bba: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110bbd: c9 leave <== NOT EXECUTED 110bbe: c3 ret <== NOT EXECUTED 110bbf: 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 */ 110bc0: 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 ); 110bc7: 51 push %ecx <== NOT EXECUTED 110bc8: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 110bc9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110bcc: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 110bcf: 50 push %eax <== NOT EXECUTED 110bd0: e8 b7 c7 ff ff call 10d38c <_Watchdog_Remove> <== NOT EXECUTED 110bd5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110bd8: eb c9 jmp 110ba3 <_Thread_queue_Extract_fifo+0x2f> <== NOT EXECUTED 0010fcf0 <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, bool requeuing ) { 10fcf0: 55 push %ebp <== NOT EXECUTED 10fcf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fcf3: 57 push %edi <== NOT EXECUTED 10fcf4: 56 push %esi <== NOT EXECUTED 10fcf5: 53 push %ebx <== NOT EXECUTED 10fcf6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fcf9: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10fcfc: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 10fcff: 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 ); 10fd02: 9c pushf <== NOT EXECUTED 10fd03: fa cli <== NOT EXECUTED 10fd04: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10fd07: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) <== NOT EXECUTED 10fd0e: 74 68 je 10fd78 <_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; 10fd10: 8b 33 mov (%ebx),%esi <== NOT EXECUTED previous_node = the_node->previous; 10fd12: 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( 10fd15: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10fd18: 8d 43 3c lea 0x3c(%ebx),%eax <== NOT EXECUTED 10fd1b: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10fd1d: 74 71 je 10fd90 <_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; 10fd1f: 8b 43 40 mov 0x40(%ebx),%eax <== NOT EXECUTED 10fd22: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED new_second_node = new_first_node->next; 10fd25: 8b 3a mov (%edx),%edi <== NOT EXECUTED previous_node->next = new_first_node; 10fd27: 89 11 mov %edx,(%ecx) <== NOT EXECUTED next_node->previous = new_first_node; 10fd29: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED new_first_node->next = next_node; 10fd2c: 89 32 mov %esi,(%edx) <== NOT EXECUTED new_first_node->previous = previous_node; 10fd2e: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10fd31: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10fd34: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 10fd37: 74 17 je 10fd50 <_Thread_queue_Extract_priority_helper+0x60> <== NOT EXECUTED /* > two threads on 2-n */ new_second_node->previous = 10fd39: 8d 42 38 lea 0x38(%edx),%eax <== NOT EXECUTED 10fd3c: 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; 10fd3f: 89 7a 38 mov %edi,0x38(%edx) <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 10fd42: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10fd45: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10fd48: 8d 42 3c lea 0x3c(%edx),%eax <== NOT EXECUTED 10fd4b: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10fd4e: 89 02 mov %eax,(%edx) <== NOT EXECUTED /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 10fd50: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) <== NOT EXECUTED 10fd54: 75 2e jne 10fd84 <_Thread_queue_Extract_priority_helper+0x94> <== NOT EXECUTED _ISR_Enable( level ); return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10fd56: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10fd5a: 74 3c je 10fd98 <_Thread_queue_Extract_priority_helper+0xa8> <== NOT EXECUTED _ISR_Enable( level ); 10fd5c: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10fd5f: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10fd60: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 10fd67: 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 } 10fd6a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fd6d: 5b pop %ebx <== NOT EXECUTED 10fd6e: 5e pop %esi <== NOT EXECUTED 10fd6f: 5f pop %edi <== NOT EXECUTED 10fd70: c9 leave <== NOT EXECUTED 10fd71: e9 2e c2 ff ff jmp 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 10fd76: 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 ); 10fd78: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10fd7b: 9d popf <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10fd7c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fd7f: 5b pop %ebx <== NOT EXECUTED 10fd80: 5e pop %esi <== NOT EXECUTED 10fd81: 5f pop %edi <== NOT EXECUTED 10fd82: c9 leave <== NOT EXECUTED 10fd83: c3 ret <== NOT EXECUTED /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { _ISR_Enable( level ); 10fd84: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10fd87: 9d popf <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10fd88: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fd8b: 5b pop %ebx <== NOT EXECUTED 10fd8c: 5e pop %esi <== NOT EXECUTED 10fd8d: 5f pop %edi <== NOT EXECUTED 10fd8e: c9 leave <== NOT EXECUTED 10fd8f: 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; 10fd90: 89 31 mov %esi,(%ecx) <== NOT EXECUTED next_node->previous = previous_node; 10fd92: 89 4e 04 mov %ecx,0x4(%esi) <== NOT EXECUTED 10fd95: eb b9 jmp 10fd50 <_Thread_queue_Extract_priority_helper+0x60> <== NOT EXECUTED 10fd97: 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 */ 10fd98: 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 ); 10fd9f: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10fda2: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10fda3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fda6: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10fda9: 50 push %eax <== NOT EXECUTED 10fdaa: e8 dd d5 ff ff call 10d38c <_Watchdog_Remove> <== NOT EXECUTED 10fdaf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fdb2: eb ac jmp 10fd60 <_Thread_queue_Extract_priority_helper+0x70> <== NOT EXECUTED 0010ca28 <_Thread_queue_Extract_with_proxy>: */ bool _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 10ca28: 55 push %ebp <== NOT EXECUTED 10ca29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca2b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ca2e: 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 ) ) { 10ca31: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax) <== NOT EXECUTED 10ca38: 75 06 jne 10ca40 <_Thread_queue_Extract_with_proxy+0x18> <== NOT EXECUTED 10ca3a: 31 c0 xor %eax,%eax <== NOT EXECUTED _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); return TRUE; } return FALSE; } 10ca3c: c9 leave <== NOT EXECUTED 10ca3d: c3 ret <== NOT EXECUTED 10ca3e: 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 ); 10ca40: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ca43: 50 push %eax <== NOT EXECUTED 10ca44: ff 70 44 pushl 0x44(%eax) <== NOT EXECUTED 10ca47: e8 74 32 00 00 call 10fcc0 <_Thread_queue_Extract> <== NOT EXECUTED 10ca4c: b0 01 mov $0x1,%al <== NOT EXECUTED 10ca4e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return TRUE; } return FALSE; } 10ca51: c9 leave <== NOT EXECUTED 10ca52: c3 ret <== NOT EXECUTED 0010eb0c <_Thread_queue_First>: */ Thread_Control *_Thread_queue_First( Thread_queue_Control *the_thread_queue ) { 10eb0c: 55 push %ebp <== NOT EXECUTED 10eb0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10eb0f: 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 ) 10eb12: 83 78 34 01 cmpl $0x1,0x34(%eax) <== NOT EXECUTED 10eb16: 74 0c je 10eb24 <_Thread_queue_First+0x18> <== NOT EXECUTED 10eb18: b9 1c 1f 11 00 mov $0x111f1c,%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 ); 10eb1d: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10eb20: 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 ); 10eb21: ff e1 jmp *%ecx <== NOT EXECUTED 10eb23: 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 ) 10eb24: b9 30 eb 10 00 mov $0x10eb30,%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 ); 10eb29: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10eb2c: 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 ); 10eb2d: ff e1 jmp *%ecx <== NOT EXECUTED 00111f1c <_Thread_queue_First_fifo>: */ Thread_Control *_Thread_queue_First_fifo( Thread_queue_Control *the_thread_queue ) { 111f1c: 55 push %ebp <== NOT EXECUTED 111f1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111f1f: 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( 111f22: 8b 10 mov (%eax),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) 111f24: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 111f27: 39 c2 cmp %eax,%edx <== NOT EXECUTED 111f29: 74 05 je 111f30 <_Thread_queue_First_fifo+0x14> <== NOT EXECUTED return (Thread_Control *) the_thread_queue->Queues.Fifo.first; 111f2b: 89 d0 mov %edx,%eax <== NOT EXECUTED return NULL; } 111f2d: c9 leave <== NOT EXECUTED 111f2e: c3 ret <== NOT EXECUTED 111f2f: 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 ) ) 111f30: 31 c0 xor %eax,%eax <== NOT EXECUTED return (Thread_Control *) the_thread_queue->Queues.Fifo.first; return NULL; } 111f32: c9 leave <== NOT EXECUTED 111f33: c3 ret <== NOT EXECUTED 0010eb30 <_Thread_queue_First_priority>: */ Thread_Control *_Thread_queue_First_priority ( Thread_queue_Control *the_thread_queue ) { 10eb30: 55 push %ebp <== NOT EXECUTED 10eb31: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10eb33: 56 push %esi <== NOT EXECUTED 10eb34: 53 push %ebx <== NOT EXECUTED 10eb35: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10eb38: 31 d2 xor %edx,%edx <== NOT EXECUTED 10eb3a: 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( 10eb3c: 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 ] ) ) 10eb3f: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10eb42: 8d 44 86 04 lea 0x4(%esi,%eax,4),%eax <== NOT EXECUTED 10eb46: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10eb48: 75 12 jne 10eb5c <_Thread_queue_First_priority+0x2c> <== NOT EXECUTED { uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 10eb4a: 42 inc %edx <== NOT EXECUTED 10eb4b: 83 c1 0c add $0xc,%ecx <== NOT EXECUTED ) { uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 10eb4e: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10eb51: 75 e9 jne 10eb3c <_Thread_queue_First_priority+0xc> <== NOT EXECUTED 10eb53: 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; } 10eb55: 5b pop %ebx <== NOT EXECUTED 10eb56: 5e pop %esi <== NOT EXECUTED 10eb57: c9 leave <== NOT EXECUTED 10eb58: c3 ret <== NOT EXECUTED 10eb59: 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 *) 10eb5c: 89 d8 mov %ebx,%eax <== NOT EXECUTED the_thread_queue->Queues.Priority[ index ].first; } return NULL; } 10eb5e: 5b pop %ebx <== NOT EXECUTED 10eb5f: 5e pop %esi <== NOT EXECUTED 10eb60: c9 leave <== NOT EXECUTED 10eb61: c3 ret <== NOT EXECUTED 0010ca54 <_Thread_queue_Flush>: void _Thread_queue_Flush( Thread_queue_Control *the_thread_queue, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 10ca54: 55 push %ebp <== NOT EXECUTED 10ca55: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca57: 56 push %esi <== NOT EXECUTED 10ca58: 53 push %ebx <== NOT EXECUTED 10ca59: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10ca5c: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10ca5f: eb 06 jmp 10ca67 <_Thread_queue_Flush+0x13> <== NOT EXECUTED 10ca61: 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; 10ca64: 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 )) ) { 10ca67: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ca6a: 56 push %esi <== NOT EXECUTED 10ca6b: e8 60 fc ff ff call 10c6d0 <_Thread_queue_Dequeue> <== NOT EXECUTED 10ca70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ca73: 85 c0 test %eax,%eax <== NOT EXECUTED 10ca75: 75 ed jne 10ca64 <_Thread_queue_Flush+0x10> <== NOT EXECUTED ( *remote_extract_callout )( the_thread ); else #endif the_thread->Wait.return_code = status; } } 10ca77: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ca7a: 5b pop %ebx <== NOT EXECUTED 10ca7b: 5e pop %esi <== NOT EXECUTED 10ca7c: c9 leave <== NOT EXECUTED 10ca7d: c3 ret <== NOT EXECUTED 0010ca80 <_Thread_queue_Initialize>: Thread_queue_Control *the_thread_queue, Thread_queue_Disciplines the_discipline, States_Control state, uint32_t timeout_status ) { 10ca80: 55 push %ebp <== NOT EXECUTED 10ca81: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca83: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ca86: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED the_thread_queue->state = state; 10ca89: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10ca8c: 89 51 38 mov %edx,0x38(%ecx) <== NOT EXECUTED the_thread_queue->discipline = the_discipline; 10ca8f: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED the_thread_queue->timeout_status = timeout_status; 10ca92: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10ca95: 89 51 3c mov %edx,0x3c(%ecx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10ca98: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) <== NOT EXECUTED if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10ca9f: 48 dec %eax <== NOT EXECUTED 10caa0: 74 12 je 10cab4 <_Thread_queue_Initialize+0x34> <== NOT EXECUTED 10caa2: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10caa5: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10caa7: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10caae: 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 ); } } 10cab1: c9 leave <== NOT EXECUTED 10cab2: c3 ret <== NOT EXECUTED 10cab3: 90 nop <== NOT EXECUTED 10cab4: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10cab7: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10cab9: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10cac0: 89 49 08 mov %ecx,0x8(%ecx) <== NOT EXECUTED 10cac3: 8d 41 10 lea 0x10(%ecx),%eax <== NOT EXECUTED 10cac6: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED 10cac9: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx) <== NOT EXECUTED 10cad0: 8d 41 0c lea 0xc(%ecx),%eax <== NOT EXECUTED 10cad3: 89 41 14 mov %eax,0x14(%ecx) <== NOT EXECUTED 10cad6: 8d 41 1c lea 0x1c(%ecx),%eax <== NOT EXECUTED 10cad9: 89 41 18 mov %eax,0x18(%ecx) <== NOT EXECUTED 10cadc: c7 41 1c 00 00 00 00 movl $0x0,0x1c(%ecx) <== NOT EXECUTED 10cae3: 8d 41 18 lea 0x18(%ecx),%eax <== NOT EXECUTED 10cae6: 89 41 20 mov %eax,0x20(%ecx) <== NOT EXECUTED 10cae9: 8d 41 28 lea 0x28(%ecx),%eax <== NOT EXECUTED 10caec: 89 41 24 mov %eax,0x24(%ecx) <== NOT EXECUTED 10caef: c7 41 28 00 00 00 00 movl $0x0,0x28(%ecx) <== NOT EXECUTED 10caf6: 8d 41 24 lea 0x24(%ecx),%eax <== NOT EXECUTED 10caf9: 89 41 2c mov %eax,0x2c(%ecx) <== NOT EXECUTED 10cafc: c9 leave <== NOT EXECUTED 10cafd: c3 ret <== NOT EXECUTED 0010fdb4 <_Thread_queue_Process_timeout>: #include void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { 10fdb4: 55 push %ebp <== NOT EXECUTED 10fdb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fdb7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10fdba: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 10fdbd: 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 && 10fdc0: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10fdc3: 85 c0 test %eax,%eax <== NOT EXECUTED 10fdc5: 74 08 je 10fdcf <_Thread_queue_Process_timeout+0x1b> <== NOT EXECUTED 10fdc7: 3b 0d 7c f8 11 00 cmp 0x11f87c,%ecx <== NOT EXECUTED 10fdcd: 74 19 je 10fde8 <_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; 10fdcf: 8b 42 3c mov 0x3c(%edx),%eax <== NOT EXECUTED 10fdd2: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10fdd5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10fdd8: 51 push %ecx <== NOT EXECUTED 10fdd9: ff 71 44 pushl 0x44(%ecx) <== NOT EXECUTED 10fddc: e8 df fe ff ff call 10fcc0 <_Thread_queue_Extract> <== NOT EXECUTED 10fde1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 10fde4: c9 leave <== NOT EXECUTED 10fde5: c3 ret <== NOT EXECUTED 10fde6: 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 ) { 10fde8: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10fdeb: 74 f7 je 10fde4 <_Thread_queue_Process_timeout+0x30> <== NOT EXECUTED the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10fded: 8b 42 3c mov 0x3c(%edx),%eax <== NOT EXECUTED 10fdf0: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10fdf3: 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 ); } } 10fdfa: c9 leave <== NOT EXECUTED 10fdfb: c3 ret <== NOT EXECUTED 0010cb00 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10cb00: 55 push %ebp <== NOT EXECUTED 10cb01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cb03: 56 push %esi <== NOT EXECUTED 10cb04: 53 push %ebx <== NOT EXECUTED 10cb05: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10cb08: 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 ) 10cb0b: 85 db test %ebx,%ebx <== NOT EXECUTED 10cb0d: 74 06 je 10cb15 <_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 ) { 10cb0f: 83 7b 34 01 cmpl $0x1,0x34(%ebx) <== NOT EXECUTED 10cb13: 74 07 je 10cb1c <_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 ); } } 10cb15: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10cb18: 5b pop %ebx <== NOT EXECUTED 10cb19: 5e pop %esi <== NOT EXECUTED 10cb1a: c9 leave <== NOT EXECUTED 10cb1b: 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 ); 10cb1c: 9c pushf <== NOT EXECUTED 10cb1d: fa cli <== NOT EXECUTED 10cb1e: 5e pop %esi <== NOT EXECUTED if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10cb1f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10cb22: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax) <== NOT EXECUTED 10cb29: 75 09 jne 10cb34 <_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 ); 10cb2b: 56 push %esi <== NOT EXECUTED 10cb2c: 9d popf <== NOT EXECUTED } } 10cb2d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10cb30: 5b pop %ebx <== NOT EXECUTED 10cb31: 5e pop %esi <== NOT EXECUTED 10cb32: c9 leave <== NOT EXECUTED 10cb33: 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 10cb34: 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 ); 10cb3b: 52 push %edx <== NOT EXECUTED 10cb3c: 6a 01 push $0x1 <== NOT EXECUTED 10cb3e: 50 push %eax <== NOT EXECUTED 10cb3f: 53 push %ebx <== NOT EXECUTED 10cb40: e8 ab 31 00 00 call 10fcf0 <_Thread_queue_Extract_priority_helper> <== NOT EXECUTED (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10cb45: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10cb48: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10cb4b: 50 push %eax <== NOT EXECUTED 10cb4c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10cb4f: 53 push %ebx <== NOT EXECUTED 10cb50: e8 4f fd ff ff call 10c8a4 <_Thread_queue_Enqueue_priority> <== NOT EXECUTED 10cb55: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cb58: eb d1 jmp 10cb2b <_Thread_queue_Requeue+0x2b> <== NOT EXECUTED 0010cb5c <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 10cb5c: 55 push %ebp <== NOT EXECUTED 10cb5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cb5f: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10cb62: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10cb65: 50 push %eax <== NOT EXECUTED 10cb66: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cb69: e8 02 f8 ff ff call 10c370 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10cb6e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cb71: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10cb74: 85 d2 test %edx,%edx <== NOT EXECUTED 10cb76: 75 17 jne 10cb8f <_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 ); 10cb78: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cb7b: 50 push %eax <== NOT EXECUTED 10cb7c: e8 33 32 00 00 call 10fdb4 <_Thread_queue_Process_timeout> <== NOT EXECUTED 10cb81: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10cb86: 48 dec %eax <== NOT EXECUTED 10cb87: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED 10cb8c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Unnest_dispatch(); break; } } 10cb8f: c9 leave <== NOT EXECUTED 10cb90: c3 ret <== NOT EXECUTED 0010f38c <_Timer_Manager_initialization>: */ void _Timer_Manager_initialization( uint32_t maximum_timers ) { 10f38c: 55 push %ebp <== NOT EXECUTED 10f38d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f38f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f392: 6a 04 push $0x4 <== NOT EXECUTED 10f394: 6a 00 push $0x0 <== NOT EXECUTED 10f396: 6a 3c push $0x3c <== NOT EXECUTED 10f398: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f39b: 6a 02 push $0x2 <== NOT EXECUTED 10f39d: 6a 02 push $0x2 <== NOT EXECUTED 10f39f: 68 80 03 12 00 push $0x120380 <== NOT EXECUTED 10f3a4: e8 c3 c7 ff ff call 10bb6c <_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; 10f3a9: c7 05 c4 03 12 00 00 movl $0x0,0x1203c4 <== NOT EXECUTED 10f3b0: 00 00 00 <== NOT EXECUTED _Timer_Server_schedule_operation = NULL; 10f3b3: c7 05 c0 03 12 00 00 movl $0x0,0x1203c0 <== NOT EXECUTED 10f3ba: 00 00 00 <== NOT EXECUTED 10f3bd: 83 c4 20 add $0x20,%esp <== NOT EXECUTED } 10f3c0: c9 leave <== NOT EXECUTED 10f3c1: 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 e4 6e 13 00 mov 0x136ee4,%eax <== NOT EXECUTED 114c7d: a3 d0 6c 13 00 mov %eax,0x136cd0 <== NOT EXECUTED _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 114c82: a1 0c 6e 13 00 mov 0x136e0c,%eax <== NOT EXECUTED 114c87: a3 cc 6c 13 00 mov %eax,0x136ccc <== 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 78 6d 13 00 mov 0x136d78,%eax <== NOT EXECUTED 114c91: 40 inc %eax <== NOT EXECUTED 114c92: a3 78 6d 13 00 mov %eax,0x136d78 <== 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 e3 27 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 114ca1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 114ca4: a1 78 6d 13 00 mov 0x136d78,%eax <== NOT EXECUTED 114ca9: 40 inc %eax <== NOT EXECUTED 114caa: a3 78 6d 13 00 mov %eax,0x136d78 <== 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 e4 77 13 00 pushl 0x1377e4 <== NOT EXECUTED 114cba: e8 bd 31 00 00 call 117e7c <_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 c0 6c 13 00 mov 0x136cc0,%edx <== NOT EXECUTED _Timer_Server_reset_ticks_timer(); 114cc5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114cc8: 81 fa c4 6c 13 00 cmp $0x136cc4,%edx <== NOT EXECUTED 114cce: 74 1f je 114cef <_Timer_Server_body+0x93> <== NOT EXECUTED 114cd0: a1 e4 77 13 00 mov 0x1377e4,%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 5c 6e 13 00 push $0x136e5c <== NOT EXECUTED 114ce7: e8 60 3a 00 00 call 11874c <_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 d4 6c 13 00 mov 0x136cd4,%eax <== NOT EXECUTED _Timer_Server_reset_seconds_timer(); 114cf4: 3d d8 6c 13 00 cmp $0x136cd8,%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 0c 6d 13 00 mov %eax,0x136d0c <== NOT EXECUTED size_t size ); 114d03: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114d06: 68 00 6d 13 00 push $0x136d00 <== NOT EXECUTED 114d0b: 68 50 6e 13 00 push $0x136e50 <== NOT EXECUTED 114d10: e8 37 3a 00 00 call 11874c <_Watchdog_Insert> <== NOT EXECUTED 114d15: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Enable_dispatch(); 114d18: e8 67 27 00 00 call 117484 <_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 78 6d 13 00 mov 0x136d78,%eax <== NOT EXECUTED 114d22: 40 inc %eax <== NOT EXECUTED 114d23: a3 78 6d 13 00 mov %eax,0x136d78 <== 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 e4 77 13 00 mov 0x1377e4,%eax <== NOT EXECUTED 114d30: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 114d33: 50 push %eax <== NOT EXECUTED 114d34: e8 43 3b 00 00 call 11887c <_Watchdog_Remove> <== NOT EXECUTED _Timer_Server_stop_seconds_timer(); 114d39: c7 04 24 00 6d 13 00 movl $0x136d00,(%esp) <== NOT EXECUTED 114d40: e8 37 3b 00 00 call 11887c <_Watchdog_Remove> <== NOT EXECUTED ) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 114d45: 8b 15 e4 6e 13 00 mov 0x136ee4,%edx <== NOT EXECUTED if ( snapshot >= _Timer_Server_ticks_last_time ) 114d4b: a1 d0 6c 13 00 mov 0x136cd0,%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 d0 6c 13 00 mov %edx,0x136cd0 <== 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 c0 6c 13 00 push $0x136cc0 <== NOT EXECUTED 114d6b: e8 48 39 00 00 call 1186b8 <_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 0c 6e 13 00 mov 0x136e0c,%ebx <== NOT EXECUTED if ( snapshot > _Timer_Server_seconds_last_time ) { 114d76: a1 cc 6c 13 00 mov 0x136ccc,%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 cc 6c 13 00 mov %ebx,0x136ccc <== 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 f0 26 00 00 call 117484 <_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 d4 6c 13 00 push $0x136cd4 <== NOT EXECUTED 114de8: e8 cb 38 00 00 call 1186b8 <_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 d4 6c 13 00 push $0x136cd4 <== NOT EXECUTED 114dff: e8 38 38 00 00 call 11863c <_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 e0 6c 13 00 push $0x136ce0 <== NOT EXECUTED 114c16: e8 0d 09 00 00 call 115528 <_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 c0 6c 13 00 push $0x136cc0 <== NOT EXECUTED 114c36: e8 11 3b 00 00 call 11874c <_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 d4 6c 13 00 push $0x136cd4 <== NOT EXECUTED 114c4c: e8 fb 3a 00 00 call 11874c <_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 e0 6c 13 00 push $0x136ce0 <== NOT EXECUTED 114bce: e8 31 09 00 00 call 115504 <_Chain_Append> <== NOT EXECUTED _Watchdog_Remove( &_Timer_Server->Timer ); 114bd3: a1 e4 77 13 00 mov 0x1377e4,%eax <== NOT EXECUTED 114bd8: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 114bdb: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 114bde: e8 99 3c 00 00 call 11887c <_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 e4 77 13 00 mov 0x1377e4,%eax <== NOT EXECUTED 114bec: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 114bef: e8 f8 26 00 00 call 1172ec <_Thread_Delay_ended> <== NOT EXECUTED 114bf4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 114bf7: c9 leave <== NOT EXECUTED 114bf8: c3 ret <== NOT EXECUTED 0010cf7c <_Timespec_Add_to>: uint32_t _Timespec_Add_to( struct timespec *time, const struct timespec *add ) { 10cf7c: 55 push %ebp <== NOT EXECUTED 10cf7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cf7f: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10cf82: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED uint32_t seconds = add->tv_sec; 10cf85: 8b 08 mov (%eax),%ecx <== NOT EXECUTED /* Add the basics */ time->tv_sec += add->tv_sec; 10cf87: 01 0a add %ecx,(%edx) <== NOT EXECUTED time->tv_nsec += add->tv_nsec; 10cf89: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10cf8c: 03 42 04 add 0x4(%edx),%eax <== NOT EXECUTED 10cf8f: 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 ) { 10cf92: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 10cf97: 76 15 jbe 10cfae <_Timespec_Add_to+0x32> <== NOT EXECUTED 10cf99: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 10cf9c: 2d 00 ca 9a 3b sub $0x3b9aca00,%eax <== NOT EXECUTED 10cfa1: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED time->tv_sec++; 10cfa4: ff 02 incl (%edx) <== NOT EXECUTED seconds++; 10cfa6: 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 ) { 10cfa7: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 10cfac: 77 ee ja 10cf9c <_Timespec_Add_to+0x20> <== NOT EXECUTED time->tv_sec++; seconds++; } return seconds; } 10cfae: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10cfb0: c9 leave <== NOT EXECUTED 10cfb1: c3 ret <== NOT EXECUTED 0010e638 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 10e638: 55 push %ebp <== NOT EXECUTED 10e639: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e63b: 57 push %edi <== NOT EXECUTED 10e63c: 56 push %esi <== NOT EXECUTED 10e63d: 53 push %ebx <== NOT EXECUTED 10e63e: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 10e641: 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; 10e644: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10e646: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED left += lhs->tv_nsec; 10e649: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10e64c: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10e64f: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx <== NOT EXECUTED 10e654: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10e657: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10e659: f7 e9 imul %ecx <== NOT EXECUTED 10e65b: 89 c6 mov %eax,%esi <== NOT EXECUTED 10e65d: 89 d7 mov %edx,%edi <== NOT EXECUTED right += rhs->tv_nsec; 10e65f: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10e662: 99 cltd <== NOT EXECUTED 10e663: 01 c6 add %eax,%esi <== NOT EXECUTED 10e665: 11 d7 adc %edx,%edi <== NOT EXECUTED if ( right == 0 ) { 10e667: 89 f8 mov %edi,%eax <== NOT EXECUTED 10e669: 09 f0 or %esi,%eax <== NOT EXECUTED 10e66b: 74 77 je 10e6e4 <_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; 10e66d: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10e670: f7 e9 imul %ecx <== NOT EXECUTED 10e672: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10e675: 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; 10e678: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 10e67b: 99 cltd <== NOT EXECUTED 10e67c: 01 45 e0 add %eax,-0x20(%ebp) <== NOT EXECUTED 10e67f: 11 55 e4 adc %edx,-0x1c(%ebp) <== NOT EXECUTED 10e682: 69 5d e4 a0 86 01 00 imul $0x186a0,-0x1c(%ebp),%ebx <== NOT EXECUTED 10e689: b9 a0 86 01 00 mov $0x186a0,%ecx <== NOT EXECUTED 10e68e: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10e691: f7 e1 mul %ecx <== NOT EXECUTED 10e693: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 10e696: 01 da add %ebx,%edx <== NOT EXECUTED 10e698: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED 10e69b: 57 push %edi <== NOT EXECUTED 10e69c: 56 push %esi <== NOT EXECUTED 10e69d: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 10e6a0: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED 10e6a3: e8 c0 b2 00 00 call 119968 <__udivdi3> <== NOT EXECUTED 10e6a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e6ab: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10e6ad: 89 d6 mov %edx,%esi <== NOT EXECUTED *ival_percentage = answer / 1000; 10e6af: 6a 00 push $0x0 <== NOT EXECUTED 10e6b1: 68 e8 03 00 00 push $0x3e8 <== NOT EXECUTED 10e6b6: 52 push %edx <== NOT EXECUTED 10e6b7: 50 push %eax <== NOT EXECUTED 10e6b8: e8 ab b2 00 00 call 119968 <__udivdi3> <== NOT EXECUTED 10e6bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e6c0: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10e6c3: 89 01 mov %eax,(%ecx) <== NOT EXECUTED *fval_percentage = answer % 1000; 10e6c5: 6a 00 push $0x0 <== NOT EXECUTED 10e6c7: 68 e8 03 00 00 push $0x3e8 <== NOT EXECUTED 10e6cc: 56 push %esi <== NOT EXECUTED 10e6cd: 53 push %ebx <== NOT EXECUTED 10e6ce: e8 a1 b3 00 00 call 119a74 <__umoddi3> <== NOT EXECUTED 10e6d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e6d6: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 10e6d9: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } 10e6db: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e6de: 5b pop %ebx <== NOT EXECUTED 10e6df: 5e pop %esi <== NOT EXECUTED 10e6e0: 5f pop %edi <== NOT EXECUTED 10e6e1: c9 leave <== NOT EXECUTED 10e6e2: c3 ret <== NOT EXECUTED 10e6e3: 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; 10e6e4: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10e6e7: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED *fval_percentage = 0; 10e6ed: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10e6f0: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED answer = (left * 100000) / right; *ival_percentage = answer / 1000; *fval_percentage = answer % 1000; } 10e6f6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e6f9: 5b pop %ebx <== NOT EXECUTED 10e6fa: 5e pop %esi <== NOT EXECUTED 10e6fb: 5f pop %edi <== NOT EXECUTED 10e6fc: c9 leave <== NOT EXECUTED 10e6fd: c3 ret <== NOT EXECUTED 00127724 <_Timespec_Divide_by_integer>: void _Timespec_Divide_by_integer( const struct timespec *time, uint32_t iterations, struct timespec *result ) { 127724: 55 push %ebp <== NOT EXECUTED 127725: 89 e5 mov %esp,%ebp <== NOT EXECUTED 127727: 57 push %edi <== NOT EXECUTED 127728: 56 push %esi <== NOT EXECUTED 127729: 53 push %ebx <== NOT EXECUTED 12772a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12772d: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 127730: 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; 127733: 8b 06 mov (%esi),%eax <== NOT EXECUTED 127735: 99 cltd <== NOT EXECUTED t *= TOD_NANOSECONDS_PER_SECOND; 127736: 69 da 00 ca 9a 3b imul $0x3b9aca00,%edx,%ebx <== NOT EXECUTED 12773c: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx <== NOT EXECUTED 127741: f7 e1 mul %ecx <== NOT EXECUTED 127743: 8d 14 13 lea (%ebx,%edx,1),%edx <== NOT EXECUTED t += time->tv_nsec; 127746: 8b 4e 04 mov 0x4(%esi),%ecx <== NOT EXECUTED 127749: 89 cb mov %ecx,%ebx <== NOT EXECUTED 12774b: c1 fb 1f sar $0x1f,%ebx <== NOT EXECUTED 12774e: 01 c8 add %ecx,%eax <== NOT EXECUTED 127750: 11 da adc %ebx,%edx <== NOT EXECUTED /* * Divide to get nanoseconds per iteration */ t /= iterations; 127752: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 127755: 31 db xor %ebx,%ebx <== NOT EXECUTED 127757: 53 push %ebx <== NOT EXECUTED 127758: 51 push %ecx <== NOT EXECUTED 127759: 52 push %edx <== NOT EXECUTED 12775a: 50 push %eax <== NOT EXECUTED 12775b: e8 2c 7f 01 00 call 13f68c <__udivdi3> <== NOT EXECUTED 127760: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 127763: 89 c3 mov %eax,%ebx <== NOT EXECUTED 127765: 89 d6 mov %edx,%esi <== NOT EXECUTED /* * Put it back in the timespec result */ result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND; 127767: 6a 00 push $0x0 <== NOT EXECUTED 127769: 68 00 ca 9a 3b push $0x3b9aca00 <== NOT EXECUTED 12776e: 52 push %edx <== NOT EXECUTED 12776f: 50 push %eax <== NOT EXECUTED 127770: e8 17 7f 01 00 call 13f68c <__udivdi3> <== NOT EXECUTED 127775: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 127778: 89 07 mov %eax,(%edi) <== NOT EXECUTED result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND; 12777a: 6a 00 push $0x0 <== NOT EXECUTED 12777c: 68 00 ca 9a 3b push $0x3b9aca00 <== NOT EXECUTED 127781: 56 push %esi <== NOT EXECUTED 127782: 53 push %ebx <== NOT EXECUTED 127783: e8 10 80 01 00 call 13f798 <__umoddi3> <== NOT EXECUTED 127788: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12778b: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED } 12778e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 127791: 5b pop %ebx <== NOT EXECUTED 127792: 5e pop %esi <== NOT EXECUTED 127793: 5f pop %edi <== NOT EXECUTED 127794: c9 leave <== NOT EXECUTED 127795: c3 ret <== NOT EXECUTED 00116fdc <_Timespec_From_ticks>: void _Timespec_From_ticks( uint32_t ticks, struct timespec *time ) { 116fdc: 55 push %ebp <== NOT EXECUTED 116fdd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116fdf: 53 push %ebx <== NOT EXECUTED 116fe0: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 116fe3: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED uint32_t usecs; usecs = ticks * _TOD_Microseconds_per_tick; 116fe6: 0f af 1d 80 de 12 00 imul 0x12de80,%ebx <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 116fed: ba 83 de 1b 43 mov $0x431bde83,%edx <== NOT EXECUTED 116ff2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 116ff4: f7 e2 mul %edx <== NOT EXECUTED 116ff6: c1 ea 12 shr $0x12,%edx <== NOT EXECUTED 116ff9: 89 11 mov %edx,(%ecx) <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 116ffb: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 116ffe: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 117001: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 117004: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 117007: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 11700a: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 11700d: c1 e2 06 shl $0x6,%edx <== NOT EXECUTED 117010: 29 d3 sub %edx,%ebx <== NOT EXECUTED 117012: 8d 04 9b lea (%ebx,%ebx,4),%eax <== NOT EXECUTED 117015: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 117018: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 11701b: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED 11701e: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED TOD_NANOSECONDS_PER_MICROSECOND; } 117021: 5b pop %ebx <== NOT EXECUTED 117022: c9 leave <== NOT EXECUTED 117023: c3 ret <== NOT EXECUTED 0010ec40 <_Timespec_Greater_than>: bool _Timespec_Greater_than( const struct timespec *lhs, const struct timespec *rhs ) { 10ec40: 55 push %ebp <== NOT EXECUTED 10ec41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ec43: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10ec46: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED if ( lhs->tv_sec > rhs->tv_sec ) 10ec49: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10ec4b: 39 02 cmp %eax,(%edx) <== NOT EXECUTED 10ec4d: 7f 11 jg 10ec60 <_Timespec_Greater_than+0x20> <== NOT EXECUTED return TRUE; if ( lhs->tv_sec < rhs->tv_sec ) 10ec4f: 7c 0b jl 10ec5c <_Timespec_Greater_than+0x1c> <== NOT EXECUTED return FALSE; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec > rhs->tv_nsec ) 10ec51: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10ec54: 3b 41 04 cmp 0x4(%ecx),%eax <== NOT EXECUTED 10ec57: 0f 9f c0 setg %al <== NOT EXECUTED return TRUE; return FALSE; } 10ec5a: c9 leave <== NOT EXECUTED 10ec5b: c3 ret <== NOT EXECUTED ) { if ( lhs->tv_sec > rhs->tv_sec ) return TRUE; if ( lhs->tv_sec < rhs->tv_sec ) 10ec5c: 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; } 10ec5e: c9 leave <== NOT EXECUTED 10ec5f: c3 ret <== NOT EXECUTED bool _Timespec_Greater_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec > rhs->tv_sec ) 10ec60: 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; } 10ec62: c9 leave <== NOT EXECUTED 10ec63: c3 ret <== NOT EXECUTED 00117024 <_Timespec_Is_valid>: #include bool _Timespec_Is_valid( const struct timespec *time ) { 117024: 55 push %ebp <== NOT EXECUTED 117025: 89 e5 mov %esp,%ebp <== NOT EXECUTED 117027: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !time ) 11702a: 85 c0 test %eax,%eax <== NOT EXECUTED 11702c: 74 1a je 117048 <_Timespec_Is_valid+0x24> <== NOT EXECUTED return FALSE; if ( time->tv_sec < 0 ) 11702e: 8b 10 mov (%eax),%edx <== NOT EXECUTED 117030: 85 d2 test %edx,%edx <== NOT EXECUTED 117032: 78 14 js 117048 <_Timespec_Is_valid+0x24> <== NOT EXECUTED return FALSE; if ( time->tv_nsec < 0 ) 117034: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 117037: 85 c0 test %eax,%eax <== NOT EXECUTED 117039: 78 0d js 117048 <_Timespec_Is_valid+0x24> <== NOT EXECUTED 11703b: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 117040: 0f 96 c0 setbe %al <== NOT EXECUTED if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return FALSE; return TRUE; } 117043: c9 leave <== NOT EXECUTED 117044: c3 ret <== NOT EXECUTED 117045: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return FALSE; if ( time->tv_sec < 0 ) return FALSE; if ( time->tv_nsec < 0 ) 117048: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return FALSE; return TRUE; } 11704a: c9 leave <== NOT EXECUTED 11704b: c3 ret <== NOT EXECUTED 0010ffe4 <_Timespec_Less_than>: bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { 10ffe4: 55 push %ebp <== NOT EXECUTED 10ffe5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ffe7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10ffea: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED if ( lhs->tv_sec < rhs->tv_sec ) 10ffed: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10ffef: 39 02 cmp %eax,(%edx) <== NOT EXECUTED 10fff1: 7c 11 jl 110004 <_Timespec_Less_than+0x20> <== NOT EXECUTED return TRUE; if ( lhs->tv_sec > rhs->tv_sec ) 10fff3: 7f 0b jg 110000 <_Timespec_Less_than+0x1c> <== NOT EXECUTED return FALSE; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) 10fff5: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10fff8: 3b 41 04 cmp 0x4(%ecx),%eax <== NOT EXECUTED 10fffb: 0f 9c c0 setl %al <== NOT EXECUTED return TRUE; return FALSE; } 10fffe: c9 leave <== NOT EXECUTED 10ffff: c3 ret <== NOT EXECUTED ) { if ( lhs->tv_sec < rhs->tv_sec ) return TRUE; if ( lhs->tv_sec > rhs->tv_sec ) 110000: 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; } 110002: c9 leave <== NOT EXECUTED 110003: c3 ret <== NOT EXECUTED bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec < rhs->tv_sec ) 110004: 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; } 110006: c9 leave <== NOT EXECUTED 110007: c3 ret <== NOT EXECUTED 0010cfb4 <_Timespec_Subtract>: void _Timespec_Subtract( const struct timespec *start, const struct timespec *end, struct timespec *result ) { 10cfb4: 55 push %ebp <== NOT EXECUTED 10cfb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cfb7: 53 push %ebx <== NOT EXECUTED 10cfb8: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10cfbb: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10cfbe: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED if (end->tv_nsec < start->tv_nsec) { 10cfc1: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 10cfc4: 3b 51 04 cmp 0x4(%ecx),%edx <== NOT EXECUTED 10cfc7: 7c 0f jl 10cfd8 <_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; 10cfc9: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10cfcb: 2b 01 sub (%ecx),%eax <== NOT EXECUTED 10cfcd: 89 03 mov %eax,(%ebx) <== NOT EXECUTED result->tv_nsec = end->tv_nsec - start->tv_nsec; 10cfcf: 2b 51 04 sub 0x4(%ecx),%edx <== NOT EXECUTED 10cfd2: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED } } 10cfd5: 5b pop %ebx <== NOT EXECUTED 10cfd6: c9 leave <== NOT EXECUTED 10cfd7: c3 ret <== NOT EXECUTED struct timespec *result ) { if (end->tv_nsec < start->tv_nsec) { result->tv_sec = end->tv_sec - start->tv_sec - 1; 10cfd8: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10cfda: 48 dec %eax <== NOT EXECUTED 10cfdb: 2b 01 sub (%ecx),%eax <== NOT EXECUTED 10cfdd: 89 03 mov %eax,(%ebx) <== NOT EXECUTED result->tv_nsec = 10cfdf: 8d 82 00 ca 9a 3b lea 0x3b9aca00(%edx),%eax <== NOT EXECUTED 10cfe5: 2b 41 04 sub 0x4(%ecx),%eax <== NOT EXECUTED 10cfe8: 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; } } 10cfeb: 5b pop %ebx <== NOT EXECUTED 10cfec: c9 leave <== NOT EXECUTED 10cfed: c3 ret <== NOT EXECUTED 0010ff00 <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 10ff00: 55 push %ebp <== NOT EXECUTED 10ff01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ff03: 57 push %edi <== NOT EXECUTED 10ff04: 56 push %esi <== NOT EXECUTED 10ff05: 53 push %ebx <== NOT EXECUTED 10ff06: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ff09: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 10ff0c: 8b 30 mov (%eax),%esi <== NOT EXECUTED 10ff0e: 85 f6 test %esi,%esi <== NOT EXECUTED 10ff10: 74 3e je 10ff50 <_Timespec_To_ticks+0x50> <== NOT EXECUTED 10ff12: 8b 58 04 mov 0x4(%eax),%ebx <== NOT EXECUTED return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 10ff15: 8b 0d 80 f9 11 00 mov 0x11f980,%ecx <== NOT EXECUTED 10ff1b: bf 40 42 0f 00 mov $0xf4240,%edi <== NOT EXECUTED 10ff20: 89 f8 mov %edi,%eax <== NOT EXECUTED 10ff22: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ff24: f7 f1 div %ecx <== NOT EXECUTED 10ff26: 89 c7 mov %eax,%edi <== NOT EXECUTED 10ff28: 0f af fe imul %esi,%edi <== NOT EXECUTED ticks += (time->tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND) / 10ff2b: be d3 4d 62 10 mov $0x10624dd3,%esi <== NOT EXECUTED 10ff30: 89 f0 mov %esi,%eax <== NOT EXECUTED 10ff32: f7 e3 mul %ebx <== NOT EXECUTED 10ff34: 89 d3 mov %edx,%ebx <== NOT EXECUTED 10ff36: c1 eb 06 shr $0x6,%ebx <== NOT EXECUTED 10ff39: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10ff3b: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ff3d: f7 f1 div %ecx <== NOT EXECUTED _TOD_Microseconds_per_tick; if (ticks) 10ff3f: 01 f8 add %edi,%eax <== NOT EXECUTED 10ff41: 75 05 jne 10ff48 <_Timespec_To_ticks+0x48> <== NOT EXECUTED 10ff43: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED return ticks; return 1; } 10ff48: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10ff4b: 5b pop %ebx <== NOT EXECUTED 10ff4c: 5e pop %esi <== NOT EXECUTED 10ff4d: 5f pop %edi <== NOT EXECUTED 10ff4e: c9 leave <== NOT EXECUTED 10ff4f: c3 ret <== NOT EXECUTED const struct timespec *time ) { uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 10ff50: 8b 58 04 mov 0x4(%eax),%ebx <== NOT EXECUTED 10ff53: 85 db test %ebx,%ebx <== NOT EXECUTED 10ff55: 75 be jne 10ff15 <_Timespec_To_ticks+0x15> <== NOT EXECUTED 10ff57: 31 c0 xor %eax,%eax <== NOT EXECUTED if (ticks) return ticks; return 1; } 10ff59: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10ff5c: 5b pop %ebx <== NOT EXECUTED 10ff5d: 5e pop %esi <== NOT EXECUTED 10ff5e: 5f pop %edi <== NOT EXECUTED 10ff5f: c9 leave <== NOT EXECUTED 10ff60: c3 ret <== NOT EXECUTED 0010ff64 <_User_extensions_Add_API_set>: */ void _User_extensions_Add_API_set ( User_extensions_Control *the_extension ) { 10ff64: 55 push %ebp <== NOT EXECUTED 10ff65: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ff67: 53 push %ebx <== NOT EXECUTED 10ff68: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ff6b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED _Chain_Append( &_User_extensions_List, &the_extension->Node ); 10ff6e: 53 push %ebx <== NOT EXECUTED 10ff6f: 68 0c fa 11 00 push $0x11fa0c <== NOT EXECUTED 10ff74: e8 63 ae ff ff call 10addc <_Chain_Append> <== NOT EXECUTED /* * If a switch handler is present, append it to the switch chain. */ if ( the_extension->Callouts.thread_switch != NULL ) { 10ff79: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 10ff7c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ff7f: 85 c0 test %eax,%eax <== NOT EXECUTED 10ff81: 74 17 je 10ff9a <_User_extensions_Add_API_set+0x36> <== NOT EXECUTED the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch; 10ff83: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _Chain_Append( 10ff86: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ff89: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10ff8c: 50 push %eax <== NOT EXECUTED 10ff8d: 68 bc f7 11 00 push $0x11f7bc <== NOT EXECUTED 10ff92: e8 45 ae ff ff call 10addc <_Chain_Append> <== NOT EXECUTED 10ff97: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10ff9a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ff9d: c9 leave <== NOT EXECUTED 10ff9e: c3 ret <== NOT EXECUTED 0010ffa0 <_User_extensions_Add_set>: void _User_extensions_Add_set ( User_extensions_Control *the_extension, User_extensions_Table *extension_table ) { 10ffa0: 55 push %ebp <== NOT EXECUTED 10ffa1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ffa3: 57 push %edi <== NOT EXECUTED 10ffa4: 56 push %esi <== NOT EXECUTED 10ffa5: 53 push %ebx <== NOT EXECUTED 10ffa6: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10ffa9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10ffac: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ffaf: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED the_extension->Callouts = *extension_table; 10ffb2: 8d 7b 14 lea 0x14(%ebx),%edi <== NOT EXECUTED 10ffb5: b9 08 00 00 00 mov $0x8,%ecx <== NOT EXECUTED 10ffba: 89 c6 mov %eax,%esi <== NOT EXECUTED 10ffbc: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED _Chain_Append( &_User_extensions_List, &the_extension->Node ); 10ffbe: 53 push %ebx <== NOT EXECUTED 10ffbf: 68 0c fa 11 00 push $0x11fa0c <== NOT EXECUTED 10ffc4: e8 13 ae ff ff call 10addc <_Chain_Append> <== NOT EXECUTED /* * If a switch handler is present, append it to the switch chain. */ if ( extension_table->thread_switch != NULL ) { 10ffc9: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10ffcc: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10ffcf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ffd2: 85 c0 test %eax,%eax <== NOT EXECUTED 10ffd4: 74 1e je 10fff4 <_User_extensions_Add_set+0x54> <== NOT EXECUTED the_extension->Switch.thread_switch = extension_table->thread_switch; 10ffd6: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _Chain_Append( 10ffd9: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10ffdc: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10ffdf: c7 45 08 bc f7 11 00 movl $0x11f7bc,0x8(%ebp) <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10ffe6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ffe9: 5b pop %ebx <== NOT EXECUTED 10ffea: 5e pop %esi <== NOT EXECUTED 10ffeb: 5f pop %edi <== NOT EXECUTED 10ffec: 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( 10ffed: e9 ea ad ff ff jmp 10addc <_Chain_Append> <== NOT EXECUTED 10fff2: 66 90 xchg %ax,%ax <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10fff4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fff7: 5b pop %ebx <== NOT EXECUTED 10fff8: 5e pop %esi <== NOT EXECUTED 10fff9: 5f pop %edi <== NOT EXECUTED 10fffa: c9 leave <== NOT EXECUTED 10fffb: c3 ret <== NOT EXECUTED 0010d10c <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) { 10d10c: 55 push %ebp <== NOT EXECUTED 10d10d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d10f: 57 push %edi <== NOT EXECUTED 10d110: 56 push %esi <== NOT EXECUTED 10d111: 53 push %ebx <== NOT EXECUTED 10d112: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d115: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10d118: 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 ; 10d11b: 8b 1d 14 fa 11 00 mov 0x11fa14,%ebx <== NOT EXECUTED !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10d121: 81 fb 0c fa 11 00 cmp $0x11fa0c,%ebx <== NOT EXECUTED 10d127: 74 20 je 10d149 <_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 ); 10d129: 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 ) 10d12c: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10d12f: 85 c0 test %eax,%eax <== NOT EXECUTED 10d131: 74 0b je 10d13e <_User_extensions_Fatal+0x32> <== NOT EXECUTED (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10d133: 52 push %edx <== NOT EXECUTED 10d134: 57 push %edi <== NOT EXECUTED 10d135: 56 push %esi <== NOT EXECUTED 10d136: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d139: ff d0 call *%eax <== NOT EXECUTED 10d13b: 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 ) { 10d13e: 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 ) ; 10d141: 81 fb 0c fa 11 00 cmp $0x11fa0c,%ebx <== NOT EXECUTED 10d147: 75 e3 jne 10d12c <_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 ); } } 10d149: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d14c: 5b pop %ebx <== NOT EXECUTED 10d14d: 5e pop %esi <== NOT EXECUTED 10d14e: 5f pop %edi <== NOT EXECUTED 10d14f: c9 leave <== NOT EXECUTED 10d150: c3 ret <== NOT EXECUTED 0010cff0 <_User_extensions_Handler_initialization>: void _User_extensions_Handler_initialization ( uint32_t number_of_extensions, User_extensions_Table *initial_extensions ) { 10cff0: 55 push %ebp <== NOT EXECUTED 10cff1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cff3: 57 push %edi <== NOT EXECUTED 10cff4: 56 push %esi <== NOT EXECUTED 10cff5: 53 push %ebx <== NOT EXECUTED 10cff6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cff9: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10cffc: c7 05 0c fa 11 00 10 movl $0x11fa10,0x11fa0c <== NOT EXECUTED 10d003: fa 11 00 <== NOT EXECUTED 10d006: c7 05 10 fa 11 00 00 movl $0x0,0x11fa10 <== NOT EXECUTED 10d00d: 00 00 00 <== NOT EXECUTED 10d010: c7 05 14 fa 11 00 0c movl $0x11fa0c,0x11fa14 <== NOT EXECUTED 10d017: fa 11 00 <== NOT EXECUTED 10d01a: c7 05 bc f7 11 00 c0 movl $0x11f7c0,0x11f7bc <== NOT EXECUTED 10d021: f7 11 00 <== NOT EXECUTED 10d024: c7 05 c0 f7 11 00 00 movl $0x0,0x11f7c0 <== NOT EXECUTED 10d02b: 00 00 00 <== NOT EXECUTED 10d02e: c7 05 c4 f7 11 00 bc movl $0x11f7bc,0x11f7c4 <== NOT EXECUTED 10d035: f7 11 00 <== NOT EXECUTED uint32_t i; _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10d038: 85 f6 test %esi,%esi <== NOT EXECUTED 10d03a: 74 50 je 10d08c <_User_extensions_Handler_initialization+0x9c> <== NOT EXECUTED extension = (User_extensions_Control *) 10d03c: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10d03f: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10d042: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 10d045: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 10d04c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d04f: 53 push %ebx <== NOT EXECUTED 10d050: e8 43 04 00 00 call 10d498 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10d055: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10d058: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d05a: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 10d05d: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 10d05f: 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++ ) { 10d061: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d064: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d067: 85 c0 test %eax,%eax <== NOT EXECUTED 10d069: 74 21 je 10d08c <_User_extensions_Handler_initialization+0x9c> <== NOT EXECUTED 10d06b: 31 db xor %ebx,%ebx <== NOT EXECUTED 10d06d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _User_extensions_Add_set (extension, &initial_extensions[i]); 10d070: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d073: 56 push %esi <== NOT EXECUTED 10d074: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10d077: e8 24 2f 00 00 call 10ffa0 <_User_extensions_Add_set> <== NOT EXECUTED extension++; 10d07c: 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++ ) { 10d080: 43 inc %ebx <== NOT EXECUTED 10d081: 83 c6 20 add $0x20,%esi <== NOT EXECUTED 10d084: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d087: 39 5d 08 cmp %ebx,0x8(%ebp) <== NOT EXECUTED 10d08a: 77 e4 ja 10d070 <_User_extensions_Handler_initialization+0x80> <== NOT EXECUTED _User_extensions_Add_set (extension, &initial_extensions[i]); extension++; } } } 10d08c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d08f: 5b pop %ebx <== NOT EXECUTED 10d090: 5e pop %esi <== NOT EXECUTED 10d091: 5f pop %edi <== NOT EXECUTED 10d092: c9 leave <== NOT EXECUTED 10d093: c3 ret <== NOT EXECUTED 00111f28 <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 111f28: 55 push %ebp <== NOT EXECUTED 111f29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111f2b: 53 push %ebx <== NOT EXECUTED 111f2c: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 111f2f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED _Chain_Extract( &the_extension->Node ); 111f32: 53 push %ebx <== NOT EXECUTED 111f33: e8 2c 45 00 00 call 116464 <_Chain_Extract> <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 111f38: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111f3b: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 111f3e: 85 c0 test %eax,%eax <== NOT EXECUTED 111f40: 74 12 je 111f54 <_User_extensions_Remove_set+0x2c> <== NOT EXECUTED _Chain_Extract( &the_extension->Switch.Node ); 111f42: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 111f45: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 111f48: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111f4b: 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 ); 111f4c: e9 13 45 00 00 jmp 116464 <_Chain_Extract> <== NOT EXECUTED 111f51: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } 111f54: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111f57: c9 leave <== NOT EXECUTED 111f58: c3 ret <== NOT EXECUTED 0010d094 <_User_extensions_Thread_begin>: */ void _User_extensions_Thread_begin ( Thread_Control *executing ) { 10d094: 55 push %ebp <== NOT EXECUTED 10d095: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d097: 56 push %esi <== NOT EXECUTED 10d098: 53 push %ebx <== NOT EXECUTED 10d099: 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 ; 10d09c: 8b 1d 0c fa 11 00 mov 0x11fa0c,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10d0a2: 81 fb 10 fa 11 00 cmp $0x11fa10,%ebx <== NOT EXECUTED 10d0a8: 74 1c je 10d0c6 <_User_extensions_Thread_begin+0x32> <== NOT EXECUTED 10d0aa: 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 ) 10d0ac: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 10d0af: 85 c0 test %eax,%eax <== NOT EXECUTED 10d0b1: 74 09 je 10d0bc <_User_extensions_Thread_begin+0x28> <== NOT EXECUTED (*the_extension->Callouts.thread_begin)( executing ); 10d0b3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d0b6: 56 push %esi <== NOT EXECUTED 10d0b7: ff d0 call *%eax <== NOT EXECUTED 10d0b9: 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 ) { 10d0bc: 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 ) ; 10d0be: 81 fb 10 fa 11 00 cmp $0x11fa10,%ebx <== NOT EXECUTED 10d0c4: 75 e6 jne 10d0ac <_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 ); } } 10d0c6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d0c9: 5b pop %ebx <== NOT EXECUTED 10d0ca: 5e pop %esi <== NOT EXECUTED 10d0cb: c9 leave <== NOT EXECUTED 10d0cc: c3 ret <== NOT EXECUTED 0010d154 <_User_extensions_Thread_create>: */ bool _User_extensions_Thread_create ( Thread_Control *the_thread ) { 10d154: 55 push %ebp <== NOT EXECUTED 10d155: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d157: 56 push %esi <== NOT EXECUTED 10d158: 53 push %ebx <== NOT EXECUTED 10d159: 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 ; 10d15c: 8b 1d 0c fa 11 00 mov 0x11fa0c,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10d162: 81 fb 10 fa 11 00 cmp $0x11fa10,%ebx <== NOT EXECUTED 10d168: 74 26 je 10d190 <_User_extensions_Thread_create+0x3c> <== NOT EXECUTED 10d16a: 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 ) { 10d16c: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10d16f: 85 c0 test %eax,%eax <== NOT EXECUTED 10d171: 74 13 je 10d186 <_User_extensions_Thread_create+0x32> <== NOT EXECUTED status = (*the_extension->Callouts.thread_create)( 10d173: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d176: 56 push %esi <== NOT EXECUTED 10d177: ff 35 7c f8 11 00 pushl 0x11f87c <== NOT EXECUTED 10d17d: ff d0 call *%eax <== NOT EXECUTED _Thread_Executing, the_thread ); if ( !status ) 10d17f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d182: 84 c0 test %al,%al <== NOT EXECUTED 10d184: 74 0c je 10d192 <_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 ) { 10d186: 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 ) ; 10d188: 81 fb 10 fa 11 00 cmp $0x11fa10,%ebx <== NOT EXECUTED 10d18e: 75 dc jne 10d16c <_User_extensions_Thread_create+0x18> <== NOT EXECUTED 10d190: b0 01 mov $0x1,%al <== NOT EXECUTED return FALSE; } } return TRUE; } 10d192: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d195: 5b pop %ebx <== NOT EXECUTED 10d196: 5e pop %esi <== NOT EXECUTED 10d197: c9 leave <== NOT EXECUTED 10d198: c3 ret <== NOT EXECUTED 0010d19c <_User_extensions_Thread_delete>: */ void _User_extensions_Thread_delete ( Thread_Control *the_thread ) { 10d19c: 55 push %ebp <== NOT EXECUTED 10d19d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d19f: 56 push %esi <== NOT EXECUTED 10d1a0: 53 push %ebx <== NOT EXECUTED 10d1a1: 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 ; 10d1a4: 8b 1d 14 fa 11 00 mov 0x11fa14,%ebx <== NOT EXECUTED !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10d1aa: 81 fb 0c fa 11 00 cmp $0x11fa0c,%ebx <== NOT EXECUTED 10d1b0: 74 23 je 10d1d5 <_User_extensions_Thread_delete+0x39> <== NOT EXECUTED 10d1b2: 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 ) 10d1b4: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 10d1b7: 85 c0 test %eax,%eax <== NOT EXECUTED 10d1b9: 74 0f je 10d1ca <_User_extensions_Thread_delete+0x2e> <== NOT EXECUTED (*the_extension->Callouts.thread_delete)( 10d1bb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d1be: 56 push %esi <== NOT EXECUTED 10d1bf: ff 35 7c f8 11 00 pushl 0x11f87c <== NOT EXECUTED 10d1c5: ff d0 call *%eax <== NOT EXECUTED 10d1c7: 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 ) { 10d1ca: 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 ) ; 10d1cd: 81 fb 0c fa 11 00 cmp $0x11fa0c,%ebx <== NOT EXECUTED 10d1d3: 75 df jne 10d1b4 <_User_extensions_Thread_delete+0x18> <== NOT EXECUTED (*the_extension->Callouts.thread_delete)( _Thread_Executing, the_thread ); } } 10d1d5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d1d8: 5b pop %ebx <== NOT EXECUTED 10d1d9: 5e pop %esi <== NOT EXECUTED 10d1da: c9 leave <== NOT EXECUTED 10d1db: c3 ret <== NOT EXECUTED 0010d0d0 <_User_extensions_Thread_exitted>: */ void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 10d0d0: 55 push %ebp <== NOT EXECUTED 10d0d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d0d3: 56 push %esi <== NOT EXECUTED 10d0d4: 53 push %ebx <== NOT EXECUTED 10d0d5: 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 ; 10d0d8: 8b 1d 14 fa 11 00 mov 0x11fa14,%ebx <== NOT EXECUTED !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10d0de: 81 fb 0c fa 11 00 cmp $0x11fa0c,%ebx <== NOT EXECUTED 10d0e4: 74 1d je 10d103 <_User_extensions_Thread_exitted+0x33> <== NOT EXECUTED 10d0e6: 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 ) 10d0e8: 8b 43 2c mov 0x2c(%ebx),%eax <== NOT EXECUTED 10d0eb: 85 c0 test %eax,%eax <== NOT EXECUTED 10d0ed: 74 09 je 10d0f8 <_User_extensions_Thread_exitted+0x28> <== NOT EXECUTED (*the_extension->Callouts.thread_exitted)( executing ); 10d0ef: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d0f2: 56 push %esi <== NOT EXECUTED 10d0f3: ff d0 call *%eax <== NOT EXECUTED 10d0f5: 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 ) { 10d0f8: 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 ) ; 10d0fb: 81 fb 0c fa 11 00 cmp $0x11fa0c,%ebx <== NOT EXECUTED 10d101: 75 e5 jne 10d0e8 <_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 ); } } 10d103: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d106: 5b pop %ebx <== NOT EXECUTED 10d107: 5e pop %esi <== NOT EXECUTED 10d108: c9 leave <== NOT EXECUTED 10d109: c3 ret <== NOT EXECUTED 0010dc98 <_User_extensions_Thread_restart>: */ void _User_extensions_Thread_restart ( Thread_Control *the_thread ) { 10dc98: 55 push %ebp <== NOT EXECUTED 10dc99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc9b: 56 push %esi <== NOT EXECUTED 10dc9c: 53 push %ebx <== NOT EXECUTED 10dc9d: 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 ; 10dca0: 8b 1d ec 2f 12 00 mov 0x122fec,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10dca6: 81 fb f0 2f 12 00 cmp $0x122ff0,%ebx <== NOT EXECUTED 10dcac: 74 22 je 10dcd0 <_User_extensions_Thread_restart+0x38> <== NOT EXECUTED 10dcae: 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 ) 10dcb0: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10dcb3: 85 c0 test %eax,%eax <== NOT EXECUTED 10dcb5: 74 0f je 10dcc6 <_User_extensions_Thread_restart+0x2e> <== NOT EXECUTED (*the_extension->Callouts.thread_restart)( 10dcb7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dcba: 56 push %esi <== NOT EXECUTED 10dcbb: ff 35 5c 2e 12 00 pushl 0x122e5c <== NOT EXECUTED 10dcc1: ff d0 call *%eax <== NOT EXECUTED 10dcc3: 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 ) { 10dcc6: 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 ) ; 10dcc8: 81 fb f0 2f 12 00 cmp $0x122ff0,%ebx <== NOT EXECUTED 10dcce: 75 e0 jne 10dcb0 <_User_extensions_Thread_restart+0x18> <== NOT EXECUTED (*the_extension->Callouts.thread_restart)( _Thread_Executing, the_thread ); } } 10dcd0: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10dcd3: 5b pop %ebx <== NOT EXECUTED 10dcd4: 5e pop %esi <== NOT EXECUTED 10dcd5: c9 leave <== NOT EXECUTED 10dcd6: c3 ret <== NOT EXECUTED 0010d1dc <_User_extensions_Thread_start>: */ void _User_extensions_Thread_start ( Thread_Control *the_thread ) { 10d1dc: 55 push %ebp <== NOT EXECUTED 10d1dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d1df: 56 push %esi <== NOT EXECUTED 10d1e0: 53 push %ebx <== NOT EXECUTED 10d1e1: 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 ; 10d1e4: 8b 1d 0c fa 11 00 mov 0x11fa0c,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10d1ea: 81 fb 10 fa 11 00 cmp $0x11fa10,%ebx <== NOT EXECUTED 10d1f0: 74 22 je 10d214 <_User_extensions_Thread_start+0x38> <== NOT EXECUTED 10d1f2: 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 ) 10d1f4: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10d1f7: 85 c0 test %eax,%eax <== NOT EXECUTED 10d1f9: 74 0f je 10d20a <_User_extensions_Thread_start+0x2e> <== NOT EXECUTED (*the_extension->Callouts.thread_start)( 10d1fb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d1fe: 56 push %esi <== NOT EXECUTED 10d1ff: ff 35 7c f8 11 00 pushl 0x11f87c <== NOT EXECUTED 10d205: ff d0 call *%eax <== NOT EXECUTED 10d207: 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 ) { 10d20a: 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 ) ; 10d20c: 81 fb 10 fa 11 00 cmp $0x11fa10,%ebx <== NOT EXECUTED 10d212: 75 e0 jne 10d1f4 <_User_extensions_Thread_start+0x18> <== NOT EXECUTED (*the_extension->Callouts.thread_start)( _Thread_Executing, the_thread ); } } 10d214: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d217: 5b pop %ebx <== NOT EXECUTED 10d218: 5e pop %esi <== NOT EXECUTED 10d219: c9 leave <== NOT EXECUTED 10d21a: c3 ret <== NOT EXECUTED 0010d21c <_User_extensions_Thread_switch>: */ void _User_extensions_Thread_switch ( Thread_Control *executing, Thread_Control *heir ) { 10d21c: 55 push %ebp <== NOT EXECUTED 10d21d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d21f: 57 push %edi <== NOT EXECUTED 10d220: 56 push %esi <== NOT EXECUTED 10d221: 53 push %ebx <== NOT EXECUTED 10d222: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d225: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10d228: 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 ; 10d22b: 8b 1d bc f7 11 00 mov 0x11f7bc,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; 10d231: 81 fb c0 f7 11 00 cmp $0x11f7c0,%ebx <== NOT EXECUTED 10d237: 74 18 je 10d251 <_User_extensions_Thread_switch+0x35> <== NOT EXECUTED 10d239: 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 ); 10d23c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d23f: 56 push %esi <== NOT EXECUTED 10d240: 57 push %edi <== NOT EXECUTED 10d241: 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 ) { 10d244: 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 ) ; 10d246: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d249: 81 fb c0 f7 11 00 cmp $0x11f7c0,%ebx <== NOT EXECUTED 10d24f: 75 eb jne 10d23c <_User_extensions_Thread_switch+0x20> <== NOT EXECUTED the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); } } 10d251: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d254: 5b pop %ebx <== NOT EXECUTED 10d255: 5e pop %esi <== NOT EXECUTED 10d256: 5f pop %edi <== NOT EXECUTED 10d257: c9 leave <== NOT EXECUTED 10d258: c3 ret <== NOT EXECUTED 0010ea04 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10ea04: 55 push %ebp <== NOT EXECUTED 10ea05: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ea07: 57 push %edi <== NOT EXECUTED 10ea08: 56 push %esi <== NOT EXECUTED 10ea09: 53 push %ebx <== NOT EXECUTED 10ea0a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ea0d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10ea10: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10ea13: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10ea16: 9c pushf <== NOT EXECUTED 10ea17: fa cli <== NOT EXECUTED 10ea18: 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( 10ea19: 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 10ea1b: 8d 5f 04 lea 0x4(%edi),%ebx <== NOT EXECUTED 10ea1e: 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 ) ) { 10ea21: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10ea23: 74 3f je 10ea64 <_Watchdog_Adjust+0x60> <== NOT EXECUTED switch ( direction ) { 10ea25: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ea27: 75 47 jne 10ea70 <_Watchdog_Adjust+0x6c> <== NOT EXECUTED case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10ea29: 85 f6 test %esi,%esi <== NOT EXECUTED 10ea2b: 74 37 je 10ea64 <_Watchdog_Adjust+0x60> <== NOT EXECUTED if ( units < _Watchdog_First( header )->delta_interval ) { 10ea2d: 8b 58 10 mov 0x10(%eax),%ebx <== NOT EXECUTED 10ea30: 39 de cmp %ebx,%esi <== NOT EXECUTED 10ea32: 73 0f jae 10ea43 <_Watchdog_Adjust+0x3f> <== NOT EXECUTED 10ea34: eb 42 jmp 10ea78 <_Watchdog_Adjust+0x74> <== NOT EXECUTED 10ea36: 66 90 xchg %ax,%ax <== NOT EXECUTED switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10ea38: 29 de sub %ebx,%esi <== NOT EXECUTED 10ea3a: 74 28 je 10ea64 <_Watchdog_Adjust+0x60> <== NOT EXECUTED if ( units < _Watchdog_First( header )->delta_interval ) { 10ea3c: 8b 58 10 mov 0x10(%eax),%ebx <== NOT EXECUTED 10ea3f: 39 f3 cmp %esi,%ebx <== NOT EXECUTED 10ea41: 77 35 ja 10ea78 <_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; 10ea43: c7 40 10 01 00 00 00 movl $0x1,0x10(%eax) <== NOT EXECUTED _ISR_Enable( level ); 10ea4a: 52 push %edx <== NOT EXECUTED 10ea4b: 9d popf <== NOT EXECUTED _Watchdog_Tickle( header ); 10ea4c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ea4f: 57 push %edi <== NOT EXECUTED 10ea50: e8 c7 01 00 00 call 10ec1c <_Watchdog_Tickle> <== NOT EXECUTED _ISR_Disable( level ); 10ea55: 9c pushf <== NOT EXECUTED 10ea56: fa cli <== NOT EXECUTED 10ea57: 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( 10ea58: 8b 07 mov (%edi),%eax <== NOT EXECUTED if ( _Chain_Is_empty( header ) ) 10ea5a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ea5d: 39 45 f0 cmp %eax,-0x10(%ebp) <== NOT EXECUTED 10ea60: 75 d6 jne 10ea38 <_Watchdog_Adjust+0x34> <== NOT EXECUTED 10ea62: 66 90 xchg %ax,%ax <== NOT EXECUTED } break; } } _ISR_Enable( level ); 10ea64: 52 push %edx <== NOT EXECUTED 10ea65: 9d popf <== NOT EXECUTED } 10ea66: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ea69: 5b pop %ebx <== NOT EXECUTED 10ea6a: 5e pop %esi <== NOT EXECUTED 10ea6b: 5f pop %edi <== NOT EXECUTED 10ea6c: c9 leave <== NOT EXECUTED 10ea6d: c3 ret <== NOT EXECUTED 10ea6e: 66 90 xchg %ax,%ax <== NOT EXECUTED * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { switch ( direction ) { 10ea70: 49 dec %ecx <== NOT EXECUTED 10ea71: 75 f1 jne 10ea64 <_Watchdog_Adjust+0x60> <== NOT EXECUTED case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10ea73: 01 70 10 add %esi,0x10(%eax) <== NOT EXECUTED 10ea76: eb ec jmp 10ea64 <_Watchdog_Adjust+0x60> <== NOT EXECUTED break; case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; 10ea78: 29 f3 sub %esi,%ebx <== NOT EXECUTED 10ea7a: 89 58 10 mov %ebx,0x10(%eax) <== NOT EXECUTED 10ea7d: eb e5 jmp 10ea64 <_Watchdog_Adjust+0x60> <== NOT EXECUTED 001186b8 <_Watchdog_Adjust_to_chain>: Chain_Control *header, Watchdog_Interval units_arg, Chain_Control *to_fire ) { 1186b8: 55 push %ebp <== NOT EXECUTED 1186b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1186bb: 57 push %edi <== NOT EXECUTED 1186bc: 56 push %esi <== NOT EXECUTED 1186bd: 53 push %ebx <== NOT EXECUTED 1186be: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1186c1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1186c4: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED Watchdog_Interval units = units_arg; ISR_Level level; Chain_Node *node; if ( !units ) { 1186c7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1186ca: 85 c0 test %eax,%eax <== NOT EXECUTED 1186cc: 74 6a je 118738 <_Watchdog_Adjust_to_chain+0x80> <== NOT EXECUTED return; } _ISR_Disable( level ); 1186ce: 9c pushf <== NOT EXECUTED 1186cf: fa cli <== NOT EXECUTED 1186d0: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED 1186d3: 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 1186d5: 8d 4b 04 lea 0x4(%ebx),%ecx <== NOT EXECUTED if ( !_Chain_Is_empty( header ) ) { 1186d8: 39 ca cmp %ecx,%edx <== NOT EXECUTED 1186da: 74 58 je 118734 <_Watchdog_Adjust_to_chain+0x7c> <== NOT EXECUTED 1186dc: 8b 72 10 mov 0x10(%edx),%esi <== NOT EXECUTED 1186df: 8d 47 04 lea 0x4(%edi),%eax <== NOT EXECUTED 1186e2: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 1186e5: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1186e8: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 1186eb: 90 nop <== NOT EXECUTED while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 1186ec: 3b 75 e8 cmp -0x18(%ebp),%esi <== NOT EXECUTED 1186ef: 77 3c ja 11872d <_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; 1186f1: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED 1186f8: eb 2b jmp 118725 <_Watchdog_Adjust_to_chain+0x6d> <== NOT EXECUTED 1186fa: 66 90 xchg %ax,%ax <== NOT EXECUTED 1186fc: 8b 02 mov (%edx),%eax <== NOT EXECUTED 1186fe: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 118700: 89 58 04 mov %ebx,0x4(%eax) <== NOT EXECUTED 118703: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 118706: 89 02 mov %eax,(%edx) <== NOT EXECUTED 118708: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED 11870b: 89 57 08 mov %edx,0x8(%edi) <== NOT EXECUTED 11870e: 89 10 mov %edx,(%eax) <== NOT EXECUTED 118710: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED do { node = _Chain_Get_unprotected( header ); _Chain_Append_unprotected( to_fire, node ); _ISR_Flash( level ); 118713: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 118716: 9d popf <== NOT EXECUTED 118717: 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( 118718: 8b 13 mov (%ebx),%edx <== NOT EXECUTED } while ( !_Chain_Is_empty( header ) && _Watchdog_First( header )->delta_interval == 0 ); 11871a: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 11871c: 74 16 je 118734 <_Watchdog_Adjust_to_chain+0x7c> <== NOT EXECUTED 11871e: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 118721: 85 c0 test %eax,%eax <== NOT EXECUTED 118723: 75 1b jne 118740 <_Watchdog_Adjust_to_chain+0x88> <== NOT EXECUTED 118725: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 118727: 75 d3 jne 1186fc <_Watchdog_Adjust_to_chain+0x44> <== NOT EXECUTED 118729: 31 d2 xor %edx,%edx <== NOT EXECUTED 11872b: eb d6 jmp 118703 <_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; 11872d: 2b 75 e8 sub -0x18(%ebp),%esi <== NOT EXECUTED 118730: 89 72 10 mov %esi,0x10(%edx) <== NOT EXECUTED 118733: 90 nop <== NOT EXECUTED break; } } } _ISR_Enable( level ); 118734: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 118737: 9d popf <== NOT EXECUTED } 118738: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 11873b: 5b pop %ebx <== NOT EXECUTED 11873c: 5e pop %esi <== NOT EXECUTED 11873d: 5f pop %edi <== NOT EXECUTED 11873e: c9 leave <== NOT EXECUTED 11873f: c3 ret <== NOT EXECUTED return; } _ISR_Disable( level ); if ( !_Chain_Is_empty( header ) ) { while ( units ) { 118740: 29 75 e8 sub %esi,-0x18(%ebp) <== NOT EXECUTED 118743: 74 ef je 118734 <_Watchdog_Adjust_to_chain+0x7c> <== NOT EXECUTED 118745: 89 c6 mov %eax,%esi <== NOT EXECUTED 118747: eb a3 jmp 1186ec <_Watchdog_Adjust_to_chain+0x34> <== NOT EXECUTED 0010d32c <_Watchdog_Handler_initialization>: * * Output parameters: NONE */ void _Watchdog_Handler_initialization( void ) { 10d32c: 55 push %ebp <== NOT EXECUTED 10d32d: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Watchdog_Sync_count = 0; 10d32f: c7 05 20 f9 11 00 00 movl $0x0,0x11f920 <== NOT EXECUTED 10d336: 00 00 00 <== NOT EXECUTED _Watchdog_Sync_level = 0; 10d339: c7 05 78 f8 11 00 00 movl $0x0,0x11f878 <== NOT EXECUTED 10d340: 00 00 00 <== NOT EXECUTED _Watchdog_Ticks_since_boot = 0; 10d343: c7 05 24 f9 11 00 00 movl $0x0,0x11f924 <== NOT EXECUTED 10d34a: 00 00 00 <== NOT EXECUTED 10d34d: c7 05 9c f8 11 00 a0 movl $0x11f8a0,0x11f89c <== NOT EXECUTED 10d354: f8 11 00 <== NOT EXECUTED 10d357: c7 05 a0 f8 11 00 00 movl $0x0,0x11f8a0 <== NOT EXECUTED 10d35e: 00 00 00 <== NOT EXECUTED 10d361: c7 05 a4 f8 11 00 9c movl $0x11f89c,0x11f8a4 <== NOT EXECUTED 10d368: f8 11 00 <== NOT EXECUTED 10d36b: c7 05 90 f8 11 00 94 movl $0x11f894,0x11f890 <== NOT EXECUTED 10d372: f8 11 00 <== NOT EXECUTED 10d375: c7 05 94 f8 11 00 00 movl $0x0,0x11f894 <== NOT EXECUTED 10d37c: 00 00 00 <== NOT EXECUTED 10d37f: c7 05 98 f8 11 00 90 movl $0x11f890,0x11f898 <== NOT EXECUTED 10d386: f8 11 00 <== NOT EXECUTED _Chain_Initialize_empty( &_Watchdog_Ticks_chain ); _Chain_Initialize_empty( &_Watchdog_Seconds_chain ); } 10d389: c9 leave <== NOT EXECUTED 10d38a: c3 ret <== NOT EXECUTED 0010d25c <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 10d25c: 55 push %ebp <== NOT EXECUTED 10d25d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d25f: 57 push %edi <== NOT EXECUTED 10d260: 56 push %esi <== NOT EXECUTED 10d261: 53 push %ebx <== NOT EXECUTED 10d262: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d265: 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; 10d268: 8b 3d 58 f8 11 00 mov 0x11f858,%edi <== NOT EXECUTED _ISR_Disable( level ); 10d26e: 9c pushf <== NOT EXECUTED 10d26f: fa cli <== NOT EXECUTED 10d270: 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 ) { 10d273: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10d276: 85 c0 test %eax,%eax <== NOT EXECUTED 10d278: 75 72 jne 10d2ec <_Watchdog_Insert+0x90> <== NOT EXECUTED _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 10d27a: c7 46 08 01 00 00 00 movl $0x1,0x8(%esi) <== NOT EXECUTED _Watchdog_Sync_count++; 10d281: a1 20 f9 11 00 mov 0x11f920,%eax <== NOT EXECUTED 10d286: 40 inc %eax <== NOT EXECUTED 10d287: a3 20 f9 11 00 mov %eax,0x11f920 <== NOT EXECUTED restart: delta_interval = the_watchdog->initial; 10d28c: 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 ; 10d28f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d292: 8b 08 mov (%eax),%ecx <== NOT EXECUTED ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10d294: 85 db test %ebx,%ebx <== NOT EXECUTED 10d296: 74 65 je 10d2fd <_Watchdog_Insert+0xa1> <== NOT EXECUTED 10d298: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10d29a: 85 c0 test %eax,%eax <== NOT EXECUTED 10d29c: 74 5f je 10d2fd <_Watchdog_Insert+0xa1> <== NOT EXECUTED break; if ( delta_interval < after->delta_interval ) { 10d29e: 8b 51 10 mov 0x10(%ecx),%edx <== NOT EXECUTED 10d2a1: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 10d2a3: 73 21 jae 10d2c6 <_Watchdog_Insert+0x6a> <== NOT EXECUTED 10d2a5: eb 51 jmp 10d2f8 <_Watchdog_Insert+0x9c> <== NOT EXECUTED 10d2a7: 90 nop <== NOT EXECUTED if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 10d2a8: a1 78 f8 11 00 mov 0x11f878,%eax <== NOT EXECUTED 10d2ad: 39 c7 cmp %eax,%edi <== NOT EXECUTED 10d2af: 72 6f jb 10d320 <_Watchdog_Insert+0xc4> <== NOT EXECUTED if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; break; } delta_interval -= after->delta_interval; 10d2b1: 29 d3 sub %edx,%ebx <== NOT EXECUTED ); #ifdef __cplusplus } #endif 10d2b3: 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 ) ) 10d2b5: 85 db test %ebx,%ebx <== NOT EXECUTED 10d2b7: 74 44 je 10d2fd <_Watchdog_Insert+0xa1> <== NOT EXECUTED 10d2b9: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10d2bb: 85 d2 test %edx,%edx <== NOT EXECUTED 10d2bd: 74 3e je 10d2fd <_Watchdog_Insert+0xa1> <== NOT EXECUTED break; if ( delta_interval < after->delta_interval ) { 10d2bf: 8b 51 10 mov 0x10(%ecx),%edx <== NOT EXECUTED 10d2c2: 39 da cmp %ebx,%edx <== NOT EXECUTED 10d2c4: 77 32 ja 10d2f8 <_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 ); 10d2c6: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10d2c9: 9d popf <== NOT EXECUTED 10d2ca: fa cli <== NOT EXECUTED if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 10d2cb: 83 7e 08 01 cmpl $0x1,0x8(%esi) <== NOT EXECUTED 10d2cf: 74 d7 je 10d2a8 <_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; 10d2d1: 89 3d 78 f8 11 00 mov %edi,0x11f878 <== NOT EXECUTED _Watchdog_Sync_count--; 10d2d7: a1 20 f9 11 00 mov 0x11f920,%eax <== NOT EXECUTED 10d2dc: 48 dec %eax <== NOT EXECUTED 10d2dd: a3 20 f9 11 00 mov %eax,0x11f920 <== NOT EXECUTED _ISR_Enable( level ); 10d2e2: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10d2e5: 9d popf <== NOT EXECUTED } 10d2e6: 58 pop %eax <== NOT EXECUTED 10d2e7: 5b pop %ebx <== NOT EXECUTED 10d2e8: 5e pop %esi <== NOT EXECUTED 10d2e9: 5f pop %edi <== NOT EXECUTED 10d2ea: c9 leave <== NOT EXECUTED 10d2eb: 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 ); 10d2ec: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10d2ef: 9d popf <== NOT EXECUTED exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; _Watchdog_Sync_count--; _ISR_Enable( level ); } 10d2f0: 58 pop %eax <== NOT EXECUTED 10d2f1: 5b pop %ebx <== NOT EXECUTED 10d2f2: 5e pop %esi <== NOT EXECUTED 10d2f3: 5f pop %edi <== NOT EXECUTED 10d2f4: c9 leave <== NOT EXECUTED 10d2f5: c3 ret <== NOT EXECUTED 10d2f6: 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; 10d2f8: 29 da sub %ebx,%edx <== NOT EXECUTED 10d2fa: 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( 10d2fd: c7 46 08 02 00 00 00 movl $0x2,0x8(%esi) <== NOT EXECUTED } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 10d304: 89 5e 10 mov %ebx,0x10(%esi) <== NOT EXECUTED _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 10d307: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d30a: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 10d30d: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10d30f: 89 30 mov %esi,(%eax) <== NOT EXECUTED 10d311: 89 16 mov %edx,(%esi) <== NOT EXECUTED 10d313: 89 72 04 mov %esi,0x4(%edx) <== NOT EXECUTED the_watchdog->start_time = _Watchdog_Ticks_since_boot; 10d316: a1 24 f9 11 00 mov 0x11f924,%eax <== NOT EXECUTED 10d31b: 89 46 14 mov %eax,0x14(%esi) <== NOT EXECUTED 10d31e: eb b1 jmp 10d2d1 <_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; 10d320: 89 3d 78 f8 11 00 mov %edi,0x11f878 <== NOT EXECUTED 10d326: e9 61 ff ff ff jmp 10d28c <_Watchdog_Insert+0x30> <== NOT EXECUTED 0010d38c <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10d38c: 55 push %ebp <== NOT EXECUTED 10d38d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d38f: 56 push %esi <== NOT EXECUTED 10d390: 53 push %ebx <== NOT EXECUTED 10d391: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10d394: 9c pushf <== NOT EXECUTED 10d395: fa cli <== NOT EXECUTED 10d396: 5e pop %esi <== NOT EXECUTED previous_state = the_watchdog->state; 10d397: 8b 59 08 mov 0x8(%ecx),%ebx <== NOT EXECUTED switch ( previous_state ) { 10d39a: 83 fb 01 cmp $0x1,%ebx <== NOT EXECUTED 10d39d: 74 4d je 10d3ec <_Watchdog_Remove+0x60> <== NOT EXECUTED 10d39f: 73 13 jae 10d3b4 <_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; 10d3a1: a1 24 f9 11 00 mov 0x11f924,%eax <== NOT EXECUTED 10d3a6: 89 41 18 mov %eax,0x18(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10d3a9: 56 push %esi <== NOT EXECUTED 10d3aa: 9d popf <== NOT EXECUTED return( previous_state ); } 10d3ab: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10d3ad: 5b pop %ebx <== NOT EXECUTED 10d3ae: 5e pop %esi <== NOT EXECUTED 10d3af: c9 leave <== NOT EXECUTED 10d3b0: c3 ret <== NOT EXECUTED 10d3b1: 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 ) { 10d3b4: 83 fb 03 cmp $0x3,%ebx <== NOT EXECUTED 10d3b7: 77 e8 ja 10d3a1 <_Watchdog_Remove+0x15> <== NOT EXECUTED break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10d3b9: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED ); #ifdef __cplusplus } #endif 10d3c0: 8b 11 mov (%ecx),%edx <== NOT EXECUTED next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 10d3c2: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10d3c4: 85 c0 test %eax,%eax <== NOT EXECUTED 10d3c6: 74 06 je 10d3ce <_Watchdog_Remove+0x42> <== NOT EXECUTED next_watchdog->delta_interval += the_watchdog->delta_interval; 10d3c8: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED 10d3cb: 01 42 10 add %eax,0x10(%edx) <== NOT EXECUTED if ( _Watchdog_Sync_count ) 10d3ce: a1 20 f9 11 00 mov 0x11f920,%eax <== NOT EXECUTED 10d3d3: 85 c0 test %eax,%eax <== NOT EXECUTED 10d3d5: 74 0a je 10d3e1 <_Watchdog_Remove+0x55> <== NOT EXECUTED _Watchdog_Sync_level = _ISR_Nest_level; 10d3d7: a1 58 f8 11 00 mov 0x11f858,%eax <== NOT EXECUTED 10d3dc: a3 78 f8 11 00 mov %eax,0x11f878 <== NOT EXECUTED 10d3e1: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d3e4: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10d3e7: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10d3e9: eb b6 jmp 10d3a1 <_Watchdog_Remove+0x15> <== NOT EXECUTED 10d3eb: 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; 10d3ec: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED 10d3f3: eb ac jmp 10d3a1 <_Watchdog_Remove+0x15> <== NOT EXECUTED 0010d3f8 <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 10d3f8: 55 push %ebp <== NOT EXECUTED 10d3f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d3fb: 57 push %edi <== NOT EXECUTED 10d3fc: 56 push %esi <== NOT EXECUTED 10d3fd: 53 push %ebx <== NOT EXECUTED 10d3fe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d401: 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 ); 10d404: 9c pushf <== NOT EXECUTED 10d405: fa cli <== NOT EXECUTED 10d406: 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( 10d407: 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 10d409: 8d 47 04 lea 0x4(%edi),%eax <== NOT EXECUTED 10d40c: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED if ( _Chain_Is_empty( header ) ) 10d40f: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10d411: 74 11 je 10d424 <_Watchdog_Tickle+0x2c> <== NOT EXECUTED 10d413: 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) { 10d415: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10d418: 85 c0 test %eax,%eax <== NOT EXECUTED 10d41a: 74 34 je 10d450 <_Watchdog_Tickle+0x58> <== NOT EXECUTED the_watchdog->delta_interval--; 10d41c: 48 dec %eax <== NOT EXECUTED 10d41d: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED if ( the_watchdog->delta_interval != 0 ) 10d420: 85 c0 test %eax,%eax <== NOT EXECUTED 10d422: 74 2c je 10d450 <_Watchdog_Tickle+0x58> <== NOT EXECUTED the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); 10d424: 56 push %esi <== NOT EXECUTED 10d425: 9d popf <== NOT EXECUTED } 10d426: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d429: 5b pop %ebx <== NOT EXECUTED 10d42a: 5e pop %esi <== NOT EXECUTED 10d42b: 5f pop %edi <== NOT EXECUTED 10d42c: c9 leave <== NOT EXECUTED 10d42d: c3 ret <== NOT EXECUTED _ISR_Enable( level ); switch( watchdog_state ) { case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 10d42e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d431: ff 73 24 pushl 0x24(%ebx) <== NOT EXECUTED 10d434: ff 73 20 pushl 0x20(%ebx) <== NOT EXECUTED 10d437: ff 53 1c call *0x1c(%ebx) <== NOT EXECUTED 10d43a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 10d43d: 9c pushf <== NOT EXECUTED 10d43e: fa cli <== NOT EXECUTED 10d43f: 5e pop %esi <== NOT EXECUTED 10d440: 8b 07 mov (%edi),%eax <== NOT EXECUTED the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 10d442: 39 45 f0 cmp %eax,-0x10(%ebp) <== NOT EXECUTED 10d445: 74 dd je 10d424 <_Watchdog_Tickle+0x2c> <== NOT EXECUTED 10d447: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10d449: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 10d44c: 85 c0 test %eax,%eax <== NOT EXECUTED 10d44e: 75 d4 jne 10d424 <_Watchdog_Tickle+0x2c> <== NOT EXECUTED if ( the_watchdog->delta_interval != 0 ) goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 10d450: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d453: 53 push %ebx <== NOT EXECUTED 10d454: e8 33 ff ff ff call 10d38c <_Watchdog_Remove> <== NOT EXECUTED _ISR_Enable( level ); 10d459: 56 push %esi <== NOT EXECUTED 10d45a: 9d popf <== NOT EXECUTED switch( watchdog_state ) { 10d45b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d45e: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10d461: 75 da jne 10d43d <_Watchdog_Tickle+0x45> <== NOT EXECUTED 10d463: eb c9 jmp 10d42e <_Watchdog_Tickle+0x36> <== NOT EXECUTED 0010d480 <_Workspace_Allocate>: * _Workspace_Allocate */ void *_Workspace_Allocate( size_t size ) { 10d480: 55 push %ebp <== NOT EXECUTED 10d481: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d483: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _Heap_Allocate( &_Workspace_Area, size ); 10d486: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d489: 68 e0 f7 11 00 push $0x11f7e0 <== NOT EXECUTED 10d48e: e8 a9 24 00 00 call 10f93c <_Heap_Allocate> <== NOT EXECUTED } 10d493: c9 leave <== NOT EXECUTED 10d494: c3 ret <== NOT EXECUTED 0010d498 <_Workspace_Allocate_or_fatal_error>: * _Workspace_Allocate_or_fatal_error */ void *_Workspace_Allocate_or_fatal_error( size_t size ) { 10d498: 55 push %ebp <== NOT EXECUTED 10d499: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d49b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED */ void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 10d49e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d4a1: 68 e0 f7 11 00 push $0x11f7e0 <== NOT EXECUTED 10d4a6: e8 91 24 00 00 call 10f93c <_Heap_Allocate> <== NOT EXECUTED { void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) 10d4ab: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d4ae: 85 c0 test %eax,%eax <== NOT EXECUTED 10d4b0: 74 02 je 10d4b4 <_Workspace_Allocate_or_fatal_error+0x1c> <== NOT EXECUTED TRUE, INTERNAL_ERROR_WORKSPACE_ALLOCATION ); return memory; } 10d4b2: c9 leave <== NOT EXECUTED 10d4b3: c3 ret <== NOT EXECUTED void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) _Internal_error_Occurred( 10d4b4: 50 push %eax <== NOT EXECUTED 10d4b5: 6a 04 push $0x4 <== NOT EXECUTED 10d4b7: 6a 01 push $0x1 <== NOT EXECUTED 10d4b9: 6a 00 push $0x0 <== NOT EXECUTED 10d4bb: e8 c0 e0 ff ff call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED 0010d468 <_Workspace_Free>: * _Workspace_Free */ bool _Workspace_Free( void *block ) { 10d468: 55 push %ebp <== NOT EXECUTED 10d469: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d46b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _Heap_Free( &_Workspace_Area, block ); 10d46e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d471: 68 e0 f7 11 00 push $0x11f7e0 <== NOT EXECUTED 10d476: e8 55 25 00 00 call 10f9d0 <_Heap_Free> <== NOT EXECUTED } 10d47b: c9 leave <== NOT EXECUTED 10d47c: c3 ret <== NOT EXECUTED 0010d4c0 <_Workspace_Handler_initialization>: */ void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 10d4c0: 55 push %ebp <== NOT EXECUTED 10d4c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d4c3: 57 push %edi <== NOT EXECUTED 10d4c4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d4c7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) 10d4ca: 85 d2 test %edx,%edx <== NOT EXECUTED 10d4cc: 74 2e je 10d4fc <_Workspace_Handler_initialization+0x3c> <== NOT EXECUTED 10d4ce: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 10d4d1: 75 29 jne 10d4fc <_Workspace_Handler_initialization+0x3c> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _Configuration_Table->do_zero_of_workspace ) 10d4d3: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10d4d8: 80 78 28 00 cmpb $0x0,0x28(%eax) <== NOT EXECUTED 10d4dc: 75 2a jne 10d508 <_Workspace_Handler_initialization+0x48> <== NOT EXECUTED memset( starting_address, 0, size ); memory_available = _Heap_Initialize( 10d4de: 6a 04 push $0x4 <== NOT EXECUTED 10d4e0: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d4e3: 52 push %edx <== NOT EXECUTED 10d4e4: 68 e0 f7 11 00 push $0x11f7e0 <== NOT EXECUTED 10d4e9: e8 aa de ff ff call 10b398 <_Heap_Initialize> <== NOT EXECUTED starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 10d4ee: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d4f1: 85 c0 test %eax,%eax <== NOT EXECUTED 10d4f3: 74 1e je 10d513 <_Workspace_Handler_initialization+0x53> <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); } 10d4f5: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 10d4f8: c9 leave <== NOT EXECUTED 10d4f9: c3 ret <== NOT EXECUTED 10d4fa: 66 90 xchg %ax,%ax <== NOT EXECUTED ) { uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) _Internal_error_Occurred( 10d4fc: 51 push %ecx <== NOT EXECUTED 10d4fd: 6a 02 push $0x2 <== NOT EXECUTED 10d4ff: 6a 01 push $0x1 <== NOT EXECUTED 10d501: 6a 00 push $0x0 <== NOT EXECUTED 10d503: e8 78 e0 ff ff call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _Configuration_Table->do_zero_of_workspace ) memset( starting_address, 0, size ); 10d508: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d50a: 89 d7 mov %edx,%edi <== NOT EXECUTED 10d50c: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10d50f: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 10d511: eb cb jmp 10d4de <_Workspace_Handler_initialization+0x1e> <== NOT EXECUTED size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) _Internal_error_Occurred( 10d513: 52 push %edx <== NOT EXECUTED 10d514: 6a 03 push $0x3 <== NOT EXECUTED 10d516: 6a 01 push $0x1 <== NOT EXECUTED 10d518: 6a 00 push $0x0 <== NOT EXECUTED 10d51a: e8 61 e0 ff ff call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED 00121aa8 <_kill_r>: int _kill_r( struct _reent *ptr, pid_t pid, int sig ) { 121aa8: 55 push %ebp <== NOT EXECUTED 121aa9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121aab: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 121aae: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED return killinfo( pid, sig, NULL ); 121ab1: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) <== NOT EXECUTED 121ab8: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 121abb: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 121abe: c9 leave <== NOT EXECUTED struct _reent *ptr, pid_t pid, int sig ) { return killinfo( pid, sig, NULL ); 121abf: e9 a4 00 00 00 jmp 121b68 <== NOT EXECUTED 00109fa4 : int adjtime( struct timeval *delta, struct timeval *olddelta ) { 109fa4: 55 push %ebp <== NOT EXECUTED 109fa5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109fa7: 57 push %edi <== NOT EXECUTED 109fa8: 56 push %esi <== NOT EXECUTED 109fa9: 53 push %ebx <== NOT EXECUTED 109faa: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 109fad: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 109fb0: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED long adjustment; /* * Simple validations */ if ( !delta ) 109fb3: 85 f6 test %esi,%esi <== NOT EXECUTED 109fb5: 0f 84 22 01 00 00 je 10a0dd <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND ) 109fbb: 8b 56 04 mov 0x4(%esi),%edx <== NOT EXECUTED 109fbe: 81 fa 3f 42 0f 00 cmp $0xf423f,%edx <== NOT EXECUTED 109fc4: 0f 87 13 01 00 00 ja 10a0dd <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( olddelta ) { 109fca: 85 ff test %edi,%edi <== NOT EXECUTED 109fcc: 74 10 je 109fde <== NOT EXECUTED olddelta->tv_sec = 0; 109fce: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED olddelta->tv_usec = 0; 109fd4: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) <== NOT EXECUTED 109fdb: 8b 56 04 mov 0x4(%esi),%edx <== NOT EXECUTED } /* convert delta to microseconds */ adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND); 109fde: 8b 06 mov (%esi),%eax <== NOT EXECUTED 109fe0: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 109fe3: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 109fe6: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 109fe9: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 109fec: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 109fef: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 109ff2: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED adjustment += delta->tv_usec; /* too small to account for */ if ( adjustment < _TOD_Microseconds_per_tick ) 109ff5: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED 109ff8: 3b 05 a0 09 12 00 cmp 0x1209a0,%eax <== NOT EXECUTED 109ffe: 73 0c jae 10a00c <== NOT EXECUTED _Thread_Enable_dispatch(); /* set the user's output */ if ( olddelta ) *olddelta = *delta; 10a000: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10a002: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a005: 5b pop %ebx <== NOT EXECUTED 10a006: 5e pop %esi <== NOT EXECUTED 10a007: 5f pop %edi <== NOT EXECUTED 10a008: c9 leave <== NOT EXECUTED 10a009: c3 ret <== NOT EXECUTED 10a00a: 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 10a00c: a1 d8 07 12 00 mov 0x1207d8,%eax <== NOT EXECUTED 10a011: 40 inc %eax <== NOT EXECUTED 10a012: a3 d8 07 12 00 mov %eax,0x1207d8 <== NOT EXECUTED * This prevents context switches while we are adjusting the TOD */ _Thread_Disable_dispatch(); _TOD_Get( &ts ); 10a017: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a01a: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10a01d: 50 push %eax <== NOT EXECUTED 10a01e: e8 dd 19 00 00 call 10ba00 <_TOD_Get> <== NOT EXECUTED ts.tv_sec += delta->tv_sec; 10a023: 8b 1e mov (%esi),%ebx <== NOT EXECUTED 10a025: 03 5d ec add -0x14(%ebp),%ebx <== NOT EXECUTED 10a028: 89 5d ec mov %ebx,-0x14(%ebp) <== NOT EXECUTED ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; 10a02b: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10a02e: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10a031: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10a034: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10a037: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED 10a03a: 03 45 f0 add -0x10(%ebp),%eax <== NOT EXECUTED 10a03d: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED /* if adjustment is too much positive */ while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 10a040: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a043: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 10a048: 76 3f jbe 10a089 <== NOT EXECUTED ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 10a04a: 8d 88 00 36 65 c4 lea -0x3b9aca00(%eax),%ecx <== NOT EXECUTED int adjtime( struct timeval *delta, struct timeval *olddelta ) { 10a050: 89 ca mov %ecx,%edx <== NOT EXECUTED 10a052: c1 ea 09 shr $0x9,%edx <== NOT EXECUTED 10a055: b8 83 4b 04 00 mov $0x44b83,%eax <== NOT EXECUTED 10a05a: f7 e2 mul %edx <== NOT EXECUTED 10a05c: c1 ea 07 shr $0x7,%edx <== NOT EXECUTED 10a05f: 8d 44 1a 01 lea 0x1(%edx,%ebx,1),%eax <== NOT EXECUTED 10a063: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 10a066: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10a069: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10a06c: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10a06f: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10a072: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10a075: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10a078: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10a07b: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10a07e: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10a081: c1 e2 09 shl $0x9,%edx <== NOT EXECUTED 10a084: 29 d1 sub %edx,%ecx <== NOT EXECUTED 10a086: 89 4d f0 mov %ecx,-0x10(%ebp) <== NOT EXECUTED ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; ts.tv_sec++; } /* if adjustment is too much negative */ while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) { 10a089: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10a08c: 81 fa 00 36 65 c4 cmp $0xc4653600,%edx <== NOT EXECUTED 10a092: 77 19 ja 10a0ad <== NOT EXECUTED 10a094: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10a097: 90 nop <== NOT EXECUTED ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND; 10a098: 81 c2 00 ca 9a 3b add $0x3b9aca00,%edx <== NOT EXECUTED int adjtime( struct timeval *delta, struct timeval *olddelta ) { 10a09e: 48 dec %eax <== NOT EXECUTED ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; ts.tv_sec++; } /* if adjustment is too much negative */ while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) { 10a09f: 81 fa 00 36 65 c4 cmp $0xc4653600,%edx <== NOT EXECUTED 10a0a5: 76 f1 jbe 10a098 <== NOT EXECUTED 10a0a7: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 10a0aa: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND; ts.tv_sec--; } _TOD_Set( &ts ); 10a0ad: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a0b0: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10a0b3: 50 push %eax <== NOT EXECUTED 10a0b4: e8 d7 19 00 00 call 10ba90 <_TOD_Set> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a0b9: e8 5e 2a 00 00 call 10cb1c <_Thread_Enable_dispatch> <== NOT EXECUTED /* set the user's output */ if ( olddelta ) 10a0be: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a0c1: 85 ff test %edi,%edi <== NOT EXECUTED 10a0c3: 0f 84 37 ff ff ff je 10a000 <== NOT EXECUTED *olddelta = *delta; 10a0c9: 8b 16 mov (%esi),%edx <== NOT EXECUTED 10a0cb: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10a0ce: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED 10a0d1: 89 17 mov %edx,(%edi) <== NOT EXECUTED 10a0d3: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10a0d5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a0d8: 5b pop %ebx <== NOT EXECUTED 10a0d9: 5e pop %esi <== NOT EXECUTED 10a0da: 5f pop %edi <== NOT EXECUTED 10a0db: c9 leave <== NOT EXECUTED 10a0dc: c3 ret <== NOT EXECUTED */ if ( !delta ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND ) rtems_set_errno_and_return_minus_one( EINVAL ); 10a0dd: e8 fa 73 00 00 call 1114dc <__errno> <== NOT EXECUTED 10a0e2: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10a0e8: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a0ed: e9 10 ff ff ff jmp 10a002 <== NOT EXECUTED 0010a0fc : int aio_cancel( int filedes, struct aiocb *aiocbp ) { 10a0fc: 55 push %ebp <== NOT EXECUTED 10a0fd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a0ff: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a102: e8 79 79 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a107: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a10d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a112: c9 leave <== NOT EXECUTED 10a113: c3 ret <== NOT EXECUTED 0010a114 : #include int aio_error( const struct aiocb *aiocbp ) { 10a114: 55 push %ebp <== NOT EXECUTED 10a115: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a117: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a11a: e8 61 79 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a11f: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a125: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a12a: c9 leave <== NOT EXECUTED 10a12b: c3 ret <== NOT EXECUTED 0010a12c : int aio_fsync( int op, struct aiocb *aiocbp ) { 10a12c: 55 push %ebp <== NOT EXECUTED 10a12d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a12f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a132: e8 49 79 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a137: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a13d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a142: c9 leave <== NOT EXECUTED 10a143: c3 ret <== NOT EXECUTED 0010a144 : #include int aio_read( struct aiocb *aiocbp ) { 10a144: 55 push %ebp <== NOT EXECUTED 10a145: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a147: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a14a: e8 31 79 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a14f: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a155: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a15a: c9 leave <== NOT EXECUTED 10a15b: c3 ret <== NOT EXECUTED 0010a15c : #include int aio_return( const struct aiocb *aiocbp ) { 10a15c: 55 push %ebp <== NOT EXECUTED 10a15d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a15f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a162: e8 19 79 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a167: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a16d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a172: c9 leave <== NOT EXECUTED 10a173: c3 ret <== NOT EXECUTED 0010a174 : int aio_suspend( const struct aiocb * const list[], int nent, const struct timespec *timeout ) { 10a174: 55 push %ebp <== NOT EXECUTED 10a175: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a177: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a17a: e8 01 79 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a17f: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a185: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a18a: c9 leave <== NOT EXECUTED 10a18b: c3 ret <== NOT EXECUTED 0010a18c : #include int aio_write( struct aiocb *aiocbp ) { 10a18c: 55 push %ebp <== NOT EXECUTED 10a18d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a18f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a192: e8 e9 78 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a197: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a19d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a1a2: c9 leave <== NOT EXECUTED 10a1a3: c3 ret <== NOT EXECUTED 0010bc14 : } unsigned int alarm( unsigned int seconds ) { 10bc14: 55 push %ebp <== NOT EXECUTED 10bc15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc17: 53 push %ebx <== NOT EXECUTED 10bc18: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 10bc1b: a1 bc 4f 12 00 mov 0x124fbc,%eax <== NOT EXECUTED 10bc20: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc22: 74 68 je 10bc8c <== NOT EXECUTED _Watchdog_Initialize( the_timer, _POSIX_signals_Alarm_TSR, 0, NULL ); } else { switch ( _Watchdog_Remove( the_timer ) ) { 10bc24: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bc27: 68 a0 4f 12 00 push $0x124fa0 <== NOT EXECUTED 10bc2c: e8 bf 48 00 00 call 1104f0 <_Watchdog_Remove> <== NOT EXECUTED 10bc31: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bc34: 83 e8 02 sub $0x2,%eax <== NOT EXECUTED 10bc37: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10bc3a: 77 4c ja 10bc88 <== NOT EXECUTED * The stop_time and start_time fields are snapshots of ticks since * boot. Since alarm() is dealing in seconds, we must account for * this. */ remaining = the_timer->initial - 10bc3c: 8b 0d b8 4f 12 00 mov 0x124fb8,%ecx <== NOT EXECUTED 10bc42: 2b 0d b4 4f 12 00 sub 0x124fb4,%ecx <== NOT EXECUTED 10bc48: b8 40 42 0f 00 mov $0xf4240,%eax <== NOT EXECUTED 10bc4d: 31 d2 xor %edx,%edx <== NOT EXECUTED 10bc4f: f7 35 60 52 12 00 divl 0x125260 <== NOT EXECUTED 10bc55: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10bc57: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10bc59: 31 d2 xor %edx,%edx <== NOT EXECUTED 10bc5b: f7 f3 div %ebx <== NOT EXECUTED 10bc5d: 8b 1d ac 4f 12 00 mov 0x124fac,%ebx <== NOT EXECUTED 10bc63: 29 c3 sub %eax,%ebx <== 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, 10bc65: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bc68: a3 ac 4f 12 00 mov %eax,0x124fac <== NOT EXECUTED size_t size ); 10bc6d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bc70: 68 a0 4f 12 00 push $0x124fa0 <== NOT EXECUTED 10bc75: 68 70 51 12 00 push $0x125170 <== NOT EXECUTED 10bc7a: e8 41 47 00 00 call 1103c0 <_Watchdog_Insert> <== NOT EXECUTED } _Watchdog_Insert_seconds( the_timer, seconds ); return remaining; } 10bc7f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bc81: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bc84: c9 leave <== NOT EXECUTED 10bc85: c3 ret <== NOT EXECUTED 10bc86: 66 90 xchg %ax,%ax <== NOT EXECUTED */ if ( !the_timer->routine ) { _Watchdog_Initialize( the_timer, _POSIX_signals_Alarm_TSR, 0, NULL ); } else { switch ( _Watchdog_Remove( the_timer ) ) { 10bc88: 31 db xor %ebx,%ebx <== NOT EXECUTED 10bc8a: eb d9 jmp 10bc65 <== 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. * 10bc8c: c7 05 a8 4f 12 00 00 movl $0x0,0x124fa8 <== NOT EXECUTED 10bc93: 00 00 00 <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10bc96: c7 05 bc 4f 12 00 b8 movl $0x10bcb8,0x124fbc <== NOT EXECUTED 10bc9d: bc 10 00 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10bca0: c7 05 c0 4f 12 00 00 movl $0x0,0x124fc0 <== NOT EXECUTED 10bca7: 00 00 00 <== NOT EXECUTED * the heap 10bcaa: c7 05 c4 4f 12 00 00 movl $0x0,0x124fc4 <== NOT EXECUTED 10bcb1: 00 00 00 <== NOT EXECUTED 10bcb4: 31 db xor %ebx,%ebx <== NOT EXECUTED 10bcb6: eb ad jmp 10bc65 <== NOT EXECUTED 0010a1a4 : int clock_getcpuclockid( pid_t pid, clockid_t *clock_id ) { 10a1a4: 55 push %ebp <== NOT EXECUTED 10a1a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a1a7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a1aa: e8 d1 78 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a1af: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a1b5: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a1ba: c9 leave <== NOT EXECUTED 10a1bb: c3 ret <== NOT EXECUTED 0010a1bc : int clock_getenable_attr( clockid_t clock_id, int *attr ) { 10a1bc: 55 push %ebp <== NOT EXECUTED 10a1bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a1bf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a1c2: e8 b9 78 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a1c7: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a1cd: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a1d2: c9 leave <== NOT EXECUTED 10a1d3: c3 ret <== NOT EXECUTED 0010aa48 : int clock_getres( clockid_t clock_id, struct timespec *res ) { 10aa48: 55 push %ebp <== NOT EXECUTED 10aa49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa4b: 53 push %ebx <== NOT EXECUTED 10aa4c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10aa4f: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED if ( !res ) 10aa52: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10aa54: 74 32 je 10aa88 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); switch ( clock_id ) { 10aa56: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10aa59: 48 dec %eax <== NOT EXECUTED 10aa5a: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10aa5d: 77 29 ja 10aa88 <== NOT EXECUTED case CLOCK_REALTIME: case CLOCK_PROCESS_CPUTIME: case CLOCK_THREAD_CPUTIME: if ( res ) { res->tv_sec = _TOD_Microseconds_per_tick / 1000000; 10aa5f: 8b 1d 80 35 12 00 mov 0x123580,%ebx <== NOT EXECUTED 10aa65: ba 83 de 1b 43 mov $0x431bde83,%edx <== NOT EXECUTED 10aa6a: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10aa6c: f7 e2 mul %edx <== NOT EXECUTED 10aa6e: c1 ea 12 shr $0x12,%edx <== NOT EXECUTED 10aa71: 89 11 mov %edx,(%ecx) <== NOT EXECUTED res->tv_nsec = _TOD_Microseconds_per_tick * 1000; 10aa73: 8d 04 9b lea (%ebx,%ebx,4),%eax <== NOT EXECUTED 10aa76: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10aa79: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10aa7c: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED 10aa7f: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED 10aa82: 31 c0 xor %eax,%eax <== NOT EXECUTED default: rtems_set_errno_and_return_minus_one( EINVAL ); } return 0; } 10aa84: 5a pop %edx <== NOT EXECUTED 10aa85: 5b pop %ebx <== NOT EXECUTED 10aa86: c9 leave <== NOT EXECUTED 10aa87: c3 ret <== NOT EXECUTED /* _TOD_From_ticks( _TOD_Microseconds_per_tick, res ); */ } break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10aa88: e8 53 7b 00 00 call 1125e0 <__errno> <== NOT EXECUTED 10aa8d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10aa93: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10aa98: eb ea jmp 10aa84 <== NOT EXECUTED 0010aa9c : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 10aa9c: 55 push %ebp <== NOT EXECUTED 10aa9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa9f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10aaa2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10aaa5: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !tp ) 10aaa8: 85 d2 test %edx,%edx <== NOT EXECUTED 10aaaa: 74 14 je 10aac0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) 10aaac: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10aaaf: 74 47 je 10aaf8 <== NOT EXECUTED _TOD_Get(tp); #ifdef CLOCK_MONOTONIC else if ( clock_id == CLOCK_MONOTONIC ) 10aab1: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10aab4: 74 1e je 10aad4 <== NOT EXECUTED _TOD_Get_uptime(tp); #endif #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 10aab6: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10aab9: 74 19 je 10aad4 <== NOT EXECUTED _TOD_Get_uptime(tp); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 10aabb: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10aabe: 74 24 je 10aae4 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 10aac0: e8 1b 7b 00 00 call 1125e0 <__errno> <== NOT EXECUTED 10aac5: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10aacb: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED return 0; } 10aad0: c9 leave <== NOT EXECUTED 10aad1: c3 ret <== NOT EXECUTED 10aad2: 66 90 xchg %ax,%ax <== NOT EXECUTED else if ( clock_id == CLOCK_MONOTONIC ) _TOD_Get_uptime(tp); #endif #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) _TOD_Get_uptime(tp); 10aad4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aad7: 52 push %edx <== NOT EXECUTED 10aad8: e8 df 23 00 00 call 10cebc <_TOD_Get_uptime> <== NOT EXECUTED 10aadd: 31 c0 xor %eax,%eax <== NOT EXECUTED 10aadf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } 10aae2: c9 leave <== NOT EXECUTED 10aae3: c3 ret <== NOT EXECUTED else if ( clock_id == CLOCK_PROCESS_CPUTIME ) _TOD_Get_uptime(tp); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) rtems_set_errno_and_return_minus_one( ENOSYS ); 10aae4: e8 f7 7a 00 00 call 1125e0 <__errno> <== NOT EXECUTED 10aae9: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED 10aaef: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } 10aaf4: c9 leave <== NOT EXECUTED 10aaf5: c3 ret <== NOT EXECUTED 10aaf6: 66 90 xchg %ax,%ax <== NOT EXECUTED { if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) _TOD_Get(tp); 10aaf8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aafb: 52 push %edx <== NOT EXECUTED 10aafc: e8 67 23 00 00 call 10ce68 <_TOD_Get> <== NOT EXECUTED 10ab01: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ab03: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } 10ab06: c9 leave <== NOT EXECUTED 10ab07: c3 ret <== NOT EXECUTED 0010a240 : int clock_setenable_attr( clockid_t clock_id, int attr ) { 10a240: 55 push %ebp <== NOT EXECUTED 10a241: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a243: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a246: e8 35 78 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a24b: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a251: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a256: c9 leave <== NOT EXECUTED 10a257: c3 ret <== NOT EXECUTED 00125870 : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 125870: 55 push %ebp <== NOT EXECUTED 125871: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125873: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 125876: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 125879: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !tp ) 12587c: 85 d2 test %edx,%edx <== NOT EXECUTED 12587e: 74 0f je 12588f <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 125880: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 125883: 74 33 je 1258b8 <== NOT EXECUTED _Thread_Disable_dispatch(); _TOD_Set( tp ); _Thread_Enable_dispatch(); } #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 125885: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 125888: 74 1a je 1258a4 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 12588a: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 12588d: 74 15 je 1258a4 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 12588f: e8 c0 bf 00 00 call 131854 <__errno> <== NOT EXECUTED 125894: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 12589a: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED return 0; } 12589f: c9 leave <== NOT EXECUTED 1258a0: c3 ret <== NOT EXECUTED 1258a1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED else if ( clock_id == CLOCK_PROCESS_CPUTIME ) rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) rtems_set_errno_and_return_minus_one( ENOSYS ); 1258a4: e8 ab bf 00 00 call 131854 <__errno> <== NOT EXECUTED 1258a9: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED 1258af: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } 1258b4: c9 leave <== NOT EXECUTED 1258b5: c3 ret <== NOT EXECUTED 1258b6: 66 90 xchg %ax,%ax <== NOT EXECUTED { if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 1258b8: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx) <== NOT EXECUTED 1258be: 76 cf jbe 12588f <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1258c0: a1 f8 1e 16 00 mov 0x161ef8,%eax <== NOT EXECUTED 1258c5: 40 inc %eax <== NOT EXECUTED 1258c6: a3 f8 1e 16 00 mov %eax,0x161ef8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_Disable_dispatch(); _TOD_Set( tp ); 1258cb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1258ce: 52 push %edx <== NOT EXECUTED 1258cf: e8 00 15 00 00 call 126dd4 <_TOD_Set> <== NOT EXECUTED _Thread_Enable_dispatch(); 1258d4: e8 9f be fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 1258d9: 31 c0 xor %eax,%eax <== NOT EXECUTED 1258db: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } 1258de: c9 leave <== NOT EXECUTED 1258df: c3 ret <== NOT EXECUTED 0010a2c8 : int filedes, void *dev_data_ptr, size_t nbyte, int *dev_info_ptr ) { 10a2c8: 55 push %ebp <== NOT EXECUTED 10a2c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a2cb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a2ce: e8 ad 77 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a2d3: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a2d9: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a2de: c9 leave <== NOT EXECUTED 10a2df: c3 ret <== NOT EXECUTED 0010a2f8 : const char *path, const char *arg, ... ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 10a2f8: 55 push %ebp <== NOT EXECUTED 10a2f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a2fb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a2fe: e8 7d 77 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a303: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a309: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a30e: c9 leave <== NOT EXECUTED 10a30f: c3 ret <== NOT EXECUTED 0010a2e0 : const char *path, char const *arg, ... ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 10a2e0: 55 push %ebp <== NOT EXECUTED 10a2e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a2e3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a2e6: e8 95 77 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a2eb: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a2f1: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a2f6: c9 leave <== NOT EXECUTED 10a2f7: c3 ret <== NOT EXECUTED 0010a310 : const char *file, const char *arg, ... ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 10a310: 55 push %ebp <== NOT EXECUTED 10a311: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a313: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a316: e8 65 77 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a31b: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a321: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a326: c9 leave <== NOT EXECUTED 10a327: c3 ret <== NOT EXECUTED 0010a340 : int execv( const char *file, char *const argv[] ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 10a340: 55 push %ebp <== NOT EXECUTED 10a341: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a343: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a346: e8 35 77 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a34b: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a351: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a356: c9 leave <== NOT EXECUTED 10a357: c3 ret <== NOT EXECUTED 0010a328 : const char *path, char *const argv[], char *const envp[] ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 10a328: 55 push %ebp <== NOT EXECUTED 10a329: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a32b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a32e: e8 4d 77 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a333: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a339: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a33e: c9 leave <== NOT EXECUTED 10a33f: c3 ret <== NOT EXECUTED 0010a358 : int execvp( const char *path, char *const argv[] ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 10a358: 55 push %ebp <== NOT EXECUTED 10a359: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a35b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a35e: e8 1d 77 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a363: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a369: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a36e: c9 leave <== NOT EXECUTED 10a36f: c3 ret <== NOT EXECUTED 0010a370 : #include #include int fork( void ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 10a370: 55 push %ebp <== NOT EXECUTED 10a371: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a373: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a376: e8 05 77 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a37b: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a381: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a386: c9 leave <== NOT EXECUTED 10a387: c3 ret <== NOT EXECUTED 0010a430 : int kill( pid_t pid, int sig ) { 10a430: 55 push %ebp <== NOT EXECUTED 10a431: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a433: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return killinfo( pid, sig, NULL ); 10a436: 6a 00 push $0x0 <== NOT EXECUTED 10a438: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a43b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a43e: e8 6d 5f 00 00 call 1103b0 <== NOT EXECUTED } 10a443: c9 leave <== NOT EXECUTED 10a444: c3 ret <== NOT EXECUTED 00121b68 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 121b68: 55 push %ebp <== NOT EXECUTED 121b69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121b6b: 57 push %edi <== NOT EXECUTED 121b6c: 56 push %esi <== NOT EXECUTED 121b6d: 53 push %ebx <== NOT EXECUTED 121b6e: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) 121b71: e8 0a fd ff ff call 121880 <== NOT EXECUTED 121b76: 3b 45 08 cmp 0x8(%ebp),%eax <== NOT EXECUTED 121b79: 0f 85 85 02 00 00 jne 121e04 <== NOT EXECUTED /* * Validate the signal passed. */ if ( !sig ) 121b7f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 121b82: 85 db test %ebx,%ebx <== NOT EXECUTED 121b84: 0f 84 92 02 00 00 je 121e1c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 121b8a: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 121b8d: 49 dec %ecx <== NOT EXECUTED 121b8e: 83 f9 1f cmp $0x1f,%ecx <== NOT EXECUTED 121b91: 0f 87 85 02 00 00 ja 121e1c <== NOT EXECUTED /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 121b97: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 121b9a: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 121b9d: 83 3c 85 88 e3 12 00 cmpl $0x1,0x12e388(,%eax,4) <== NOT EXECUTED 121ba4: 01 <== NOT EXECUTED 121ba5: 0f 84 e4 00 00 00 je 121c8f <== NOT EXECUTED * P1003.1c/Draft 10, p. 33 says that certain signals should always * be directed to the executing thread such as those caused by hardware * faults. */ if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) ) 121bab: 83 7d 0c 08 cmpl $0x8,0xc(%ebp) <== NOT EXECUTED 121baf: 0f 84 e7 00 00 00 je 121c9c <== NOT EXECUTED 121bb5: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) <== NOT EXECUTED 121bb9: 0f 84 dd 00 00 00 je 121c9c <== NOT EXECUTED 121bbf: 83 7d 0c 0b cmpl $0xb,0xc(%ebp) <== NOT EXECUTED 121bc3: 0f 84 d3 00 00 00 je 121c9c <== NOT EXECUTED return pthread_kill( pthread_self(), sig ); mask = signo_to_mask( sig ); 121bc9: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 121bce: d3 e6 shl %cl,%esi <== NOT EXECUTED /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 121bd0: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 121bd3: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED siginfo->si_code = SI_USER; 121bd6: c7 45 ec 01 00 00 00 movl $0x1,-0x14(%ebp) <== NOT EXECUTED if ( !value ) { 121bdd: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 121be0: 85 c9 test %ecx,%ecx <== NOT EXECUTED 121be2: 0f 84 fc 01 00 00 je 121de4 <== NOT EXECUTED siginfo->si_value.sival_int = 0; } else { siginfo->si_value = *value; 121be8: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 121beb: 8b 02 mov (%edx),%eax <== NOT EXECUTED 121bed: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 121bf0: a1 b8 dc 12 00 mov 0x12dcb8,%eax <== NOT EXECUTED 121bf5: 40 inc %eax <== NOT EXECUTED 121bf6: a3 b8 dc 12 00 mov %eax,0x12dcb8 <== NOT EXECUTED /* * Is the currently executing thread interested? If so then it will * get it an execute it as soon as the dispatcher executes. */ the_thread = _Thread_Executing; 121bfb: 8b 0d 7c dd 12 00 mov 0x12dd7c,%ecx <== NOT EXECUTED api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 121c01: 8b 81 f8 00 00 00 mov 0xf8(%ecx),%eax <== NOT EXECUTED 121c07: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED 121c0d: f7 d0 not %eax <== NOT EXECUTED 121c0f: 85 c6 test %eax,%esi <== NOT EXECUTED 121c11: 75 38 jne 121c4b <== NOT EXECUTED goto process_it; 121c13: bf 20 e5 12 00 mov $0x12e520,%edi <== NOT EXECUTED index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; 121c18: 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 121c1a: 8d 5f 04 lea 0x4(%edi),%ebx <== NOT EXECUTED !_Chain_Is_tail( the_chain, the_node ) ; 121c1d: 39 da cmp %ebx,%edx <== NOT EXECUTED 121c1f: 75 1d jne 121c3e <== NOT EXECUTED 121c21: e9 da 00 00 00 jmp 121d00 <== NOT EXECUTED 121c26: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ((the_thread->Wait.option & mask) || (~api->signals_blocked & mask)) { 121c28: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED 121c2e: f7 d0 not %eax <== NOT EXECUTED 121c30: 85 c6 test %eax,%esi <== NOT EXECUTED 121c32: 75 17 jne 121c4b <== NOT EXECUTED the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 121c34: 8b 12 mov (%edx),%edx <== NOT EXECUTED index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; 121c36: 39 da cmp %ebx,%edx <== NOT EXECUTED 121c38: 0f 84 c2 00 00 00 je 121d00 <== NOT EXECUTED the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; 121c3e: 89 d1 mov %edx,%ecx <== NOT EXECUTED api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 121c40: 8b 82 f8 00 00 00 mov 0xf8(%edx),%eax <== NOT EXECUTED if ((the_thread->Wait.option & mask) || (~api->signals_blocked & mask)) { 121c46: 85 72 30 test %esi,0x30(%edx) <== NOT EXECUTED 121c49: 74 dd je 121c28 <== NOT EXECUTED * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = true; 121c4b: c6 41 75 01 movb $0x1,0x75(%ecx) <== NOT EXECUTED /* * Returns TRUE if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { 121c4f: 50 push %eax <== NOT EXECUTED 121c50: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 121c53: 50 push %eax <== NOT EXECUTED 121c54: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 121c57: 51 push %ecx <== NOT EXECUTED 121c58: e8 0f 02 00 00 call 121e6c <_POSIX_signals_Unblock_thread> <== NOT EXECUTED 121c5d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121c60: 84 c0 test %al,%al <== NOT EXECUTED 121c62: 0f 85 8c 00 00 00 jne 121cf4 <== NOT EXECUTED /* * We may have woken up a thread but we definitely need to post the * signal to the process wide information set. */ _POSIX_signals_Set_process_signals( mask ); 121c68: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 121c6b: 56 push %esi <== NOT EXECUTED 121c6c: e8 d7 01 00 00 call 121e48 <_POSIX_signals_Set_process_signals> <== NOT EXECUTED if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 121c71: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 121c74: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 121c77: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 121c7e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121c81: 83 bb 80 e3 12 00 02 cmpl $0x2,0x12e380(%ebx) <== NOT EXECUTED 121c88: 74 2e je 121cb8 <== NOT EXECUTED psiginfo->Info = *siginfo; _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); } _Thread_Enable_dispatch(); 121c8a: e8 c9 f4 fe ff call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED 121c8f: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 121c91: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 121c94: 5b pop %ebx <== NOT EXECUTED 121c95: 5e pop %esi <== NOT EXECUTED 121c96: 5f pop %edi <== NOT EXECUTED 121c97: c9 leave <== NOT EXECUTED 121c98: c3 ret <== NOT EXECUTED 121c99: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * be directed to the executing thread such as those caused by hardware * faults. */ if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) ) return pthread_kill( pthread_self(), sig ); 121c9c: e8 af 03 00 00 call 122050 <== NOT EXECUTED 121ca1: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 121ca4: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 121ca7: 50 push %eax <== NOT EXECUTED 121ca8: e8 db 02 00 00 call 121f88 <== NOT EXECUTED 121cad: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); } _Thread_Enable_dispatch(); return 0; } 121cb0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 121cb3: 5b pop %ebx <== NOT EXECUTED 121cb4: 5e pop %esi <== NOT EXECUTED 121cb5: 5f pop %edi <== NOT EXECUTED 121cb6: c9 leave <== NOT EXECUTED 121cb7: c3 ret <== NOT EXECUTED _POSIX_signals_Set_process_signals( mask ); if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) 121cb8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 121cbb: 68 00 e5 12 00 push $0x12e500 <== NOT EXECUTED 121cc0: e8 47 df fe ff call 10fc0c <_Chain_Get> <== NOT EXECUTED _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { 121cc5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121cc8: 85 c0 test %eax,%eax <== NOT EXECUTED 121cca: 0f 84 61 01 00 00 je 121e31 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EAGAIN ); } psiginfo->Info = *siginfo; 121cd0: 8d 78 08 lea 0x8(%eax),%edi <== NOT EXECUTED 121cd3: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 121cd6: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 121cdb: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 121cdd: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 121ce0: 50 push %eax <== NOT EXECUTED 121ce1: 8d 83 80 e5 12 00 lea 0x12e580(%ebx),%eax <== NOT EXECUTED 121ce7: 50 push %eax <== NOT EXECUTED 121ce8: e8 fb de fe ff call 10fbe8 <_Chain_Append> <== NOT EXECUTED 121ced: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121cf0: eb 98 jmp 121c8a <== NOT EXECUTED 121cf2: 66 90 xchg %ax,%ax <== NOT EXECUTED * Returns TRUE if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { _Thread_Enable_dispatch(); 121cf4: e8 5f f4 fe ff call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED 121cf9: 31 c0 xor %eax,%eax <== NOT EXECUTED 121cfb: eb b3 jmp 121cb0 <== NOT EXECUTED 121cfd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; 121d00: 83 c7 0c add $0xc,%edi <== NOT EXECUTED */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 121d03: 81 ff 50 e5 12 00 cmp $0x12e550,%edi <== NOT EXECUTED 121d09: 0f 85 09 ff ff ff jne 121c18 <== NOT EXECUTED * * + rtems internal threads do not receive signals. */ interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 121d0f: 0f b6 05 f4 84 12 00 movzbl 0x1284f4,%eax <== NOT EXECUTED 121d16: 8d 78 01 lea 0x1(%eax),%edi <== NOT EXECUTED 121d19: c7 45 d4 02 00 00 00 movl $0x2,-0x2c(%ebp) <== NOT EXECUTED 121d20: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED the_api++ ) { /* * Thie can occur when no one is interested and ITRON is not configured. */ if ( !_Objects_Information_table[ the_api ] ) 121d27: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 121d2a: 8b 04 95 8c dc 12 00 mov 0x12dc8c(,%edx,4),%eax <== NOT EXECUTED 121d31: 85 c0 test %eax,%eax <== NOT EXECUTED 121d33: 0f 84 93 00 00 00 je 121dcc <== NOT EXECUTED continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 121d39: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED /* * This cannot happen in the current (as of Dec 2007) implementation * of initialization but at some point, the object information * structure for a particular manager may not be installed. */ if ( !the_info ) 121d3c: 85 c0 test %eax,%eax <== NOT EXECUTED 121d3e: 0f 84 88 00 00 00 je 121dcc <== NOT EXECUTED continue; maximum = the_info->maximum; 121d44: 0f b7 50 10 movzwl 0x10(%eax),%edx <== NOT EXECUTED 121d48: 89 55 d8 mov %edx,-0x28(%ebp) <== NOT EXECUTED object_table = the_info->local_table; 121d4b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 121d4e: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED for ( index = 1 ; index <= maximum ; index++ ) { 121d51: 85 d2 test %edx,%edx <== NOT EXECUTED 121d53: 74 77 je 121dcc <== NOT EXECUTED 121d55: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED the_thread = (Thread_Control *) object_table[ index ]; 121d5a: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 121d5d: 8b 14 88 mov (%eax,%ecx,4),%edx <== NOT EXECUTED if ( !the_thread ) 121d60: 85 d2 test %edx,%edx <== NOT EXECUTED 121d62: 74 50 je 121db4 <== NOT EXECUTED /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 121d64: 8b 5a 14 mov 0x14(%edx),%ebx <== NOT EXECUTED 121d67: 39 fb cmp %edi,%ebx <== NOT EXECUTED 121d69: 77 49 ja 121db4 <== NOT EXECUTED /* * If this thread is not interested, then go on to the next thread. */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 121d6b: 8b 82 f8 00 00 00 mov 0xf8(%edx),%eax <== NOT EXECUTED if ( !api || !_POSIX_signals_Is_interested( api, mask ) ) 121d71: 85 c0 test %eax,%eax <== NOT EXECUTED 121d73: 74 3f je 121db4 <== NOT EXECUTED 121d75: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED 121d7b: f7 d0 not %eax <== NOT EXECUTED 121d7d: 85 c6 test %eax,%esi <== NOT EXECUTED 121d7f: 74 33 je 121db4 <== NOT EXECUTED * Now we know the thread under connsideration is interested. * If the thread under consideration is of higher priority, then * it becomes the interested thread. */ if ( the_thread->current_priority < interested_priority ) { 121d81: 39 fb cmp %edi,%ebx <== NOT EXECUTED 121d83: 72 17 jb 121d9c <== NOT EXECUTED * Now the thread and the interested thread have the same priority. * If the interested thread is ready, then we don't need to send it * to a blocked thread. */ if ( _States_Is_ready( interested_thread->current_state ) ) 121d85: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 121d88: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 121d8b: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED 121d8e: 85 c0 test %eax,%eax <== NOT EXECUTED 121d90: 74 22 je 121db4 <== NOT EXECUTED * Now the interested thread is blocked. * If the thread we are considering is not, the it becomes the * interested thread. */ if ( _States_Is_ready( the_thread->current_state ) ) { 121d92: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 121d95: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 121d98: 85 c0 test %eax,%eax <== NOT EXECUTED 121d9a: 75 54 jne 121df0 <== NOT EXECUTED * If the thread under consideration is interruptible by a signal, * then it becomes the interested thread. */ /* XXX need a new states macro */ if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) { 121d9c: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED continue; maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 121d9f: 41 inc %ecx <== NOT EXECUTED 121da0: 39 4d d8 cmp %ecx,-0x28(%ebp) <== NOT EXECUTED 121da3: 72 17 jb 121dbc <== NOT EXECUTED 121da5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 121da8: 89 df mov %ebx,%edi <== NOT EXECUTED the_thread = (Thread_Control *) object_table[ index ]; 121daa: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 121dad: 8b 14 88 mov (%eax,%ecx,4),%edx <== NOT EXECUTED if ( !the_thread ) 121db0: 85 d2 test %edx,%edx <== NOT EXECUTED 121db2: 75 b0 jne 121d64 <== NOT EXECUTED * If the thread under consideration is interruptible by a signal, * then it becomes the interested thread. */ /* XXX need a new states macro */ if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) { 121db4: 89 fb mov %edi,%ebx <== NOT EXECUTED continue; maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 121db6: 41 inc %ecx <== NOT EXECUTED 121db7: 39 4d d8 cmp %ecx,-0x28(%ebp) <== NOT EXECUTED 121dba: 73 ec jae 121da8 <== NOT EXECUTED interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for ( the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 121dbc: ff 45 d4 incl -0x2c(%ebp) <== NOT EXECUTED interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for ( the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; 121dbf: 83 7d d4 05 cmpl $0x5,-0x2c(%ebp) <== NOT EXECUTED 121dc3: 74 0b je 121dd0 <== NOT EXECUTED 121dc5: 89 df mov %ebx,%edi <== NOT EXECUTED 121dc7: e9 5b ff ff ff jmp 121d27 <== NOT EXECUTED continue; maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 121dcc: 89 fb mov %edi,%ebx <== NOT EXECUTED 121dce: eb ec jmp 121dbc <== NOT EXECUTED interested_priority = the_thread->current_priority; } } } if ( interested_thread ) { 121dd0: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 121dd3: 85 d2 test %edx,%edx <== NOT EXECUTED 121dd5: 0f 84 8d fe ff ff je 121c68 <== NOT EXECUTED 121ddb: 8b 4d e0 mov -0x20(%ebp),%ecx <== NOT EXECUTED 121dde: e9 68 fe ff ff jmp 121c4b <== NOT EXECUTED 121de3: 90 nop <== NOT EXECUTED siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER; if ( !value ) { siginfo->si_value.sival_int = 0; 121de4: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED 121deb: e9 00 fe ff ff jmp 121bf0 <== NOT EXECUTED * Now we know both threads are blocked. * If the interested thread is interruptible, then just use it. */ /* XXX need a new states macro */ if ( interested_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) 121df0: f7 45 cc 00 00 00 10 testl $0x10000000,-0x34(%ebp) <== NOT EXECUTED 121df7: 75 bb jne 121db4 <== NOT EXECUTED * If the thread under consideration is interruptible by a signal, * then it becomes the interested thread. */ /* XXX need a new states macro */ if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) { 121df9: a9 00 00 00 10 test $0x10000000,%eax <== NOT EXECUTED 121dfe: 75 9c jne 121d9c <== NOT EXECUTED 121e00: 89 fb mov %edi,%ebx <== NOT EXECUTED 121e02: eb b2 jmp 121db6 <== NOT EXECUTED /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) rtems_set_errno_and_return_minus_one( ESRCH ); 121e04: e8 73 78 ff ff call 11967c <__errno> <== NOT EXECUTED 121e09: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED 121e0f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 121e14: e9 97 fe ff ff jmp 121cb0 <== NOT EXECUTED 121e19: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !sig ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) rtems_set_errno_and_return_minus_one( EINVAL ); 121e1c: e8 5b 78 ff ff call 11967c <__errno> <== NOT EXECUTED 121e21: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 121e27: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 121e2c: e9 7f fe ff ff jmp 121cb0 <== NOT EXECUTED if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { rtems_set_errno_and_return_minus_one( EAGAIN ); 121e31: e8 46 78 ff ff call 11967c <__errno> <== NOT EXECUTED 121e36: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 121e3c: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 121e41: e9 6a fe ff ff jmp 121cb0 <== NOT EXECUTED 0010a388 : int mode, struct aiocb * const list[], int nent, struct sigevent *sig ) { 10a388: 55 push %ebp <== NOT EXECUTED 10a389: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a38b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a38e: e8 ed 76 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a393: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a399: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a39e: c9 leave <== NOT EXECUTED 10a39f: c3 ret <== NOT EXECUTED 0010a3a0 : * As of gcc 4.2.2, the gcc SPARC backend doesn't appear to have a * way to call this for RTEMS anymore but it doesn't hurt to leave it. */ int mprotect(const void *addr, size_t len, int prot) { 10a3a0: 55 push %ebp <== NOT EXECUTED 10a3a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 10a3a3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a3a5: c9 leave <== NOT EXECUTED 10a3a6: c3 ret <== NOT EXECUTED 0010d850 : */ int mq_close( mqd_t mqdes ) { 10d850: 55 push %ebp <== NOT EXECUTED 10d851: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d853: 53 push %ebx <== NOT EXECUTED 10d854: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ); 10d857: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10d85a: 50 push %eax <== NOT EXECUTED 10d85b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d85e: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10d863: e8 88 35 00 00 call 110df0 <_Objects_Get> <== NOT EXECUTED 10d868: 89 c3 mov %eax,%ebx <== NOT EXECUTED POSIX_Message_queue_Control *the_mq; POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); if ( location == OBJECTS_LOCAL ) { 10d86a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d86d: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10d870: 85 c0 test %eax,%eax <== NOT EXECUTED 10d872: 75 38 jne 10d8ac <== NOT EXECUTED * First update the actual message queue to reflect this descriptor * being disassociated. This may result in the queue being really * deleted. */ the_mq = the_mq_fd->Queue; 10d874: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED the_mq->open_count -= 1; 10d877: ff 48 18 decl 0x18(%eax) <== NOT EXECUTED _POSIX_Message_queue_Delete( the_mq ); 10d87a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d87d: 50 push %eax <== NOT EXECUTED 10d87e: e8 3d 00 00 00 call 10d8c0 <_POSIX_Message_queue_Delete> <== NOT EXECUTED /* * Now close this file descriptor. */ _Objects_Close( 10d883: 59 pop %ecx <== NOT EXECUTED 10d884: 58 pop %eax <== NOT EXECUTED 10d885: 53 push %ebx <== NOT EXECUTED 10d886: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10d88b: e8 ec 30 00 00 call 11097c <_Objects_Close> <== 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 10d890: 58 pop %eax <== NOT EXECUTED 10d891: 5a pop %edx <== NOT EXECUTED 10d892: 53 push %ebx <== NOT EXECUTED 10d893: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10d898: e8 1f 34 00 00 call 110cbc <_Objects_Free> <== NOT EXECUTED &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object ); _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 10d89d: e8 e6 3d 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED 10d8a2: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d8a4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * OBJECTS_REMOTE: * OBJECTS_ERROR: */ rtems_set_errno_and_return_minus_one( EBADF ); } 10d8a7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d8aa: c9 leave <== NOT EXECUTED 10d8ab: c3 ret <== NOT EXECUTED /* * OBJECTS_REMOTE: * OBJECTS_ERROR: */ rtems_set_errno_and_return_minus_one( EBADF ); 10d8ac: e8 9b 8c 00 00 call 11654c <__errno> <== NOT EXECUTED 10d8b1: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10d8b7: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10d8bc: eb e9 jmp 10d8a7 <== NOT EXECUTED 0010d920 : int mq_getattr( mqd_t mqdes, struct mq_attr *mqstat ) { 10d920: 55 push %ebp <== NOT EXECUTED 10d921: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d923: 53 push %ebx <== NOT EXECUTED 10d924: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10d927: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED POSIX_Message_queue_Control *the_mq; POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; CORE_message_queue_Attributes *the_mq_attr; if ( !mqstat ) 10d92a: 85 db test %ebx,%ebx <== NOT EXECUTED 10d92c: 74 54 je 10d982 <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ); 10d92e: 51 push %ecx <== NOT EXECUTED 10d92f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10d932: 50 push %eax <== NOT EXECUTED 10d933: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d936: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10d93b: e8 b0 34 00 00 call 110df0 <_Objects_Get> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 10d940: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d943: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10d946: 85 d2 test %edx,%edx <== NOT EXECUTED 10d948: 75 26 jne 10d970 <== NOT EXECUTED case OBJECTS_LOCAL: the_mq = the_mq_fd->Queue; 10d94a: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED * Return the old values. */ the_mq_attr = &the_mq->Message_queue.Attributes; mqstat->mq_flags = the_mq_fd->oflag; 10d94d: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10d950: 89 03 mov %eax,(%ebx) <== NOT EXECUTED mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size; 10d952: 8b 42 68 mov 0x68(%edx),%eax <== NOT EXECUTED 10d955: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages; 10d958: 8b 42 60 mov 0x60(%edx),%eax <== NOT EXECUTED 10d95b: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages; 10d95e: 8b 42 64 mov 0x64(%edx),%eax <== NOT EXECUTED 10d961: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10d964: e8 1f 3d 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED 10d969: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); } 10d96b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d96e: c9 leave <== NOT EXECUTED 10d96f: c3 ret <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10d970: e8 d7 8b 00 00 call 11654c <__errno> <== NOT EXECUTED 10d975: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10d97b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10d980: eb e9 jmp 10d96b <== NOT EXECUTED POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; CORE_message_queue_Attributes *the_mq_attr; if ( !mqstat ) rtems_set_errno_and_return_minus_one( EINVAL ); 10d982: e8 c5 8b 00 00 call 11654c <__errno> <== NOT EXECUTED 10d987: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10d98d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10d992: eb d7 jmp 10d96b <== NOT EXECUTED 0010d994 : int mq_notify( mqd_t mqdes, const struct sigevent *notification ) { 10d994: 55 push %ebp <== NOT EXECUTED 10d995: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d997: 57 push %edi <== NOT EXECUTED 10d998: 56 push %esi <== NOT EXECUTED 10d999: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10d99c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10d99f: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10d9a2: 50 push %eax <== NOT EXECUTED 10d9a3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d9a6: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10d9ab: e8 40 34 00 00 call 110df0 <_Objects_Get> <== NOT EXECUTED POSIX_Message_queue_Control *the_mq; POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 10d9b0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d9b3: 8b 4d f4 mov -0xc(%ebp),%ecx <== NOT EXECUTED 10d9b6: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10d9b8: 74 1a je 10d9d4 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10d9ba: e8 8d 8b 00 00 call 11654c <__errno> <== NOT EXECUTED 10d9bf: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10d9c5: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10d9ca: 66 90 xchg %ax,%ax <== NOT EXECUTED } 10d9cc: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d9cf: 5e pop %esi <== NOT EXECUTED 10d9d0: 5f pop %edi <== NOT EXECUTED 10d9d1: c9 leave <== NOT EXECUTED 10d9d2: c3 ret <== NOT EXECUTED 10d9d3: 90 nop <== NOT EXECUTED the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: the_mq = the_mq_fd->Queue; 10d9d4: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED if ( notification ) { 10d9d7: 85 f6 test %esi,%esi <== NOT EXECUTED 10d9d9: 74 39 je 10da14 <== NOT EXECUTED if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) { 10d9db: 8b 50 7c mov 0x7c(%eax),%edx <== NOT EXECUTED 10d9de: 85 d2 test %edx,%edx <== NOT EXECUTED 10d9e0: 75 46 jne 10da28 <== NOT EXECUTED 10d9e2: c7 80 80 00 00 00 00 movl $0x0,0x80(%eax) <== NOT EXECUTED 10d9e9: 00 00 00 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBUSY ); } _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL ); the_mq->notification = *notification; 10d9ec: 8d b8 90 00 00 00 lea 0x90(%eax),%edi <== NOT EXECUTED 10d9f2: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 10d9f7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10d9f9: c7 40 7c 40 da 10 00 movl $0x10da40,0x7c(%eax) <== NOT EXECUTED 10da00: 89 80 80 00 00 00 mov %eax,0x80(%eax) <== NOT EXECUTED _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL ); } _Thread_Enable_dispatch(); 10da06: e8 7d 3c 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED 10da0b: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); } 10da0d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10da10: 5e pop %esi <== NOT EXECUTED 10da11: 5f pop %edi <== NOT EXECUTED 10da12: c9 leave <== NOT EXECUTED 10da13: c3 ret <== NOT EXECUTED 10da14: c7 40 7c 00 00 00 00 movl $0x0,0x7c(%eax) <== NOT EXECUTED 10da1b: c7 80 80 00 00 00 00 movl $0x0,0x80(%eax) <== NOT EXECUTED 10da22: 00 00 00 <== NOT EXECUTED 10da25: eb df jmp 10da06 <== NOT EXECUTED 10da27: 90 nop <== NOT EXECUTED case OBJECTS_LOCAL: the_mq = the_mq_fd->Queue; if ( notification ) { if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) { _Thread_Enable_dispatch(); 10da28: e8 5b 3c 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBUSY ); 10da2d: e8 1a 8b 00 00 call 11654c <__errno> <== NOT EXECUTED 10da32: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED 10da38: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10da3d: eb 8d jmp 10d9cc <== NOT EXECUTED 0010da78 : int oflag, ... /* mode_t mode, */ /* struct mq_attr attr */ ) { 10da78: 55 push %ebp <== NOT EXECUTED 10da79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10da7b: 57 push %edi <== NOT EXECUTED 10da7c: 56 push %esi <== NOT EXECUTED 10da7d: 53 push %ebx <== NOT EXECUTED 10da7e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10da81: 8b 5d 0c mov 0xc(%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 10da84: a1 58 7c 12 00 mov 0x127c58,%eax <== NOT EXECUTED 10da89: 40 inc %eax <== NOT EXECUTED 10da8a: a3 58 7c 12 00 mov %eax,0x127c58 <== NOT EXECUTED POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10da8f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10da91: 25 00 02 00 00 and $0x200,%eax <== NOT EXECUTED 10da96: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED 10da99: 0f 85 c5 00 00 00 jne 10db64 <== NOT EXECUTED 10da9f: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%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 10daa6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10daa9: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10daae: e8 49 2e 00 00 call 1108fc <_Objects_Allocate> <== NOT EXECUTED 10dab3: 89 c6 mov %eax,%esi <== NOT EXECUTED attr = (struct mq_attr *) va_arg( arg, struct mq_attr * ); va_end(arg); } the_mq_fd = _POSIX_Message_queue_Allocate_fd(); if ( !the_mq_fd ) { 10dab5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dab8: 85 c0 test %eax,%eax <== NOT EXECUTED 10daba: 0f 84 b0 00 00 00 je 10db70 <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq_fd->oflag = oflag; 10dac0: 89 58 14 mov %ebx,0x14(%eax) <== NOT EXECUTED status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); 10dac3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dac6: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10dac9: 50 push %eax <== NOT EXECUTED 10daca: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10dacd: e8 96 68 00 00 call 114368 <_POSIX_Message_queue_Name_to_id> <== NOT EXECUTED 10dad2: 89 c7 mov %eax,%edi <== NOT EXECUTED * and we can just return a pointer to the id. Otherwise we may * need to check to see if this is a "message queue does not exist" * or some other miscellaneous error on the name. */ if ( status ) { 10dad4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dad7: 85 c0 test %eax,%eax <== NOT EXECUTED 10dad9: 74 35 je 10db10 <== NOT EXECUTED /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 10dadb: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10dade: 0f 84 dc 00 00 00 je 10dbc0 <== 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 10dae4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dae7: 56 push %esi <== NOT EXECUTED 10dae8: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10daed: e8 ca 31 00 00 call 110cbc <_Objects_Free> <== NOT EXECUTED _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 10daf2: e8 91 3b 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one_cast( status, mqd_t ); 10daf7: e8 50 8a 00 00 call 11654c <__errno> <== NOT EXECUTED 10dafc: 89 38 mov %edi,(%eax) <== NOT EXECUTED 10dafe: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10db03: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ); _Thread_Enable_dispatch(); return (mqd_t) the_mq_fd->Object.id; } 10db06: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10db09: 5b pop %ebx <== NOT EXECUTED 10db0a: 5e pop %esi <== NOT EXECUTED 10db0b: 5f pop %edi <== NOT EXECUTED 10db0c: c9 leave <== NOT EXECUTED 10db0d: c3 ret <== NOT EXECUTED 10db0e: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10db10: 81 e3 00 0a 00 00 and $0xa00,%ebx <== NOT EXECUTED 10db16: 81 fb 00 0a 00 00 cmp $0xa00,%ebx <== NOT EXECUTED 10db1c: 74 72 je 10db90 <== 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 10db1e: 50 push %eax <== NOT EXECUTED 10db1f: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10db22: 50 push %eax <== NOT EXECUTED 10db23: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10db26: 68 20 80 12 00 push $0x128020 <== NOT EXECUTED 10db2b: e8 c0 32 00 00 call 110df0 <_Objects_Get> <== NOT EXECUTED /* * In this case we need to do an ID->pointer conversion to * check the mode. */ the_mq = _POSIX_Message_queue_Get( the_mq_id, &location ); 10db30: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED the_mq->open_count += 1; 10db33: ff 40 18 incl 0x18(%eax) <== NOT EXECUTED the_mq_fd->Queue = the_mq; 10db36: 89 46 10 mov %eax,0x10(%esi) <== NOT EXECUTED 10db39: 0f b7 56 08 movzwl 0x8(%esi),%edx <== NOT EXECUTED 10db3d: a1 dc 81 12 00 mov 0x1281dc,%eax <== NOT EXECUTED 10db42: 89 34 90 mov %esi,(%eax,%edx,4) <== NOT EXECUTED 10db45: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) <== NOT EXECUTED _Objects_Open_string( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 10db4c: e8 37 3b 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED _Thread_Enable_dispatch(); 10db51: e8 32 3b 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED return (mqd_t)the_mq_fd->Object.id; 10db56: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10db59: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ); _Thread_Enable_dispatch(); return (mqd_t) the_mq_fd->Object.id; } 10db5c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10db5f: 5b pop %ebx <== NOT EXECUTED 10db60: 5e pop %esi <== NOT EXECUTED 10db61: 5f pop %edi <== NOT EXECUTED 10db62: c9 leave <== NOT EXECUTED 10db63: c3 ret <== NOT EXECUTED _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); attr = (struct mq_attr *) va_arg( arg, struct mq_attr * ); 10db64: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10db67: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10db6a: e9 37 ff ff ff jmp 10daa6 <== NOT EXECUTED 10db6f: 90 nop <== NOT EXECUTED va_end(arg); } the_mq_fd = _POSIX_Message_queue_Allocate_fd(); if ( !the_mq_fd ) { _Thread_Enable_dispatch(); 10db70: e8 13 3b 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENFILE ); 10db75: e8 d2 89 00 00 call 11654c <__errno> <== NOT EXECUTED 10db7a: c7 00 17 00 00 00 movl $0x17,(%eax) <== NOT EXECUTED 10db80: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED ); _Thread_Enable_dispatch(); return (mqd_t) the_mq_fd->Object.id; } 10db85: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10db88: 5b pop %ebx <== NOT EXECUTED 10db89: 5e pop %esi <== NOT EXECUTED 10db8a: 5f pop %edi <== NOT EXECUTED 10db8b: c9 leave <== NOT EXECUTED 10db8c: c3 ret <== NOT EXECUTED 10db8d: 8d 76 00 lea 0x0(%esi),%esi <== 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 10db90: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10db93: 56 push %esi <== NOT EXECUTED 10db94: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10db99: e8 1e 31 00 00 call 110cbc <_Objects_Free> <== NOT EXECUTED * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 10db9e: e8 e5 3a 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t ); 10dba3: e8 a4 89 00 00 call 11654c <__errno> <== NOT EXECUTED 10dba8: c7 00 11 00 00 00 movl $0x11,(%eax) <== NOT EXECUTED 10dbae: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10dbb3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ); _Thread_Enable_dispatch(); return (mqd_t) the_mq_fd->Object.id; } 10dbb6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dbb9: 5b pop %ebx <== NOT EXECUTED 10dbba: 5e pop %esi <== NOT EXECUTED 10dbbb: 5f pop %edi <== NOT EXECUTED 10dbbc: c9 leave <== NOT EXECUTED 10dbbd: c3 ret <== NOT EXECUTED 10dbbe: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 10dbc0: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 10dbc3: 85 d2 test %edx,%edx <== NOT EXECUTED 10dbc5: 0f 84 19 ff ff ff je 10dae4 <== NOT EXECUTED /* * At this point, the message queue does not exist and everything has been * checked. We should go ahead and create a message queue. */ status = _POSIX_Message_queue_Create_support( 10dbcb: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10dbce: 50 push %eax <== NOT EXECUTED 10dbcf: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10dbd2: 6a 01 push $0x1 <== NOT EXECUTED 10dbd4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10dbd7: e8 dc 65 00 00 call 1141b8 <_POSIX_Message_queue_Create_support> <== NOT EXECUTED /* * errno was set by Create_support, so don't set it again. */ if ( status == -1 ) { 10dbdc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dbdf: 40 inc %eax <== NOT EXECUTED 10dbe0: 75 22 jne 10dc04 <== NOT EXECUTED _Thread_Enable_dispatch(); 10dbe2: e8 a1 3a 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED 10dbe7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dbea: 56 push %esi <== NOT EXECUTED 10dbeb: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10dbf0: e8 c7 30 00 00 call 110cbc <_Objects_Free> <== NOT EXECUTED 10dbf5: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10dbfa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dbfd: e9 04 ff ff ff jmp 10db06 <== NOT EXECUTED 10dc02: 66 90 xchg %ax,%ax <== NOT EXECUTED _POSIX_Message_queue_Free_fd( the_mq_fd ); return (mqd_t) -1; } the_mq_fd->Queue = the_mq; 10dc04: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10dc07: 89 46 10 mov %eax,0x10(%esi) <== NOT EXECUTED 10dc0a: 0f b7 56 08 movzwl 0x8(%esi),%edx <== NOT EXECUTED 10dc0e: a1 dc 81 12 00 mov 0x1281dc,%eax <== NOT EXECUTED 10dc13: 89 34 90 mov %esi,(%eax,%edx,4) <== NOT EXECUTED 10dc16: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) <== NOT EXECUTED &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 10dc1d: e8 66 3a 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED return (mqd_t) the_mq_fd->Object.id; 10dc22: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10dc25: e9 dc fe ff ff jmp 10db06 <== NOT EXECUTED 0010dc2c : mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned int *msg_prio ) { 10dc2c: 55 push %ebp <== NOT EXECUTED 10dc2d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc2f: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _POSIX_Message_queue_Receive_support( 10dc32: 6a 00 push $0x0 <== NOT EXECUTED 10dc34: 6a 01 push $0x1 <== NOT EXECUTED 10dc36: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10dc39: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dc3c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dc3f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10dc42: e8 05 00 00 00 call 10dc4c <_POSIX_Message_queue_Receive_support> <== NOT EXECUTED msg_len, msg_prio, TRUE, THREAD_QUEUE_WAIT_FOREVER ); } 10dc47: c9 leave <== NOT EXECUTED 10dc48: c3 ret <== NOT EXECUTED 0010dd6c : mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned int msg_prio ) { 10dd6c: 55 push %ebp <== NOT EXECUTED 10dd6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dd6f: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _POSIX_Message_queue_Send_support( 10dd72: 6a 00 push $0x0 <== NOT EXECUTED 10dd74: 6a 01 push $0x1 <== NOT EXECUTED 10dd76: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10dd79: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dd7c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dd7f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10dd82: e8 05 00 00 00 call 10dd8c <_POSIX_Message_queue_Send_support> <== NOT EXECUTED msg_len, msg_prio, TRUE, THREAD_QUEUE_WAIT_FOREVER ); } 10dd87: c9 leave <== NOT EXECUTED 10dd88: c3 ret <== NOT EXECUTED 0010de84 : int mq_setattr( mqd_t mqdes, const struct mq_attr *mqstat, struct mq_attr *omqstat ) { 10de84: 55 push %ebp <== NOT EXECUTED 10de85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10de87: 56 push %esi <== NOT EXECUTED 10de88: 53 push %ebx <== NOT EXECUTED 10de89: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10de8c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10de8f: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED POSIX_Message_queue_Control_fd *the_mq_fd; CORE_message_queue_Control *the_core_mq; Objects_Locations location; if ( !mqstat ) 10de92: 85 f6 test %esi,%esi <== NOT EXECUTED 10de94: 74 64 je 10defa <== NOT EXECUTED 10de96: 52 push %edx <== NOT EXECUTED 10de97: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10de9a: 50 push %eax <== NOT EXECUTED 10de9b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10de9e: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10dea3: e8 48 2f 00 00 call 110df0 <_Objects_Get> <== NOT EXECUTED 10dea8: 89 c1 mov %eax,%ecx <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 10deaa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dead: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 10deb0: 85 c0 test %eax,%eax <== NOT EXECUTED 10deb2: 75 34 jne 10dee8 <== NOT EXECUTED case OBJECTS_LOCAL: the_core_mq = &the_mq_fd->Queue->Message_queue; 10deb4: 8b 51 10 mov 0x10(%ecx),%edx <== NOT EXECUTED /* * Return the old values. */ if ( omqstat ) { 10deb7: 85 db test %ebx,%ebx <== NOT EXECUTED 10deb9: 74 17 je 10ded2 <== NOT EXECUTED omqstat->mq_flags = the_mq_fd->oflag; 10debb: 8b 41 14 mov 0x14(%ecx),%eax <== NOT EXECUTED 10debe: 89 03 mov %eax,(%ebx) <== NOT EXECUTED omqstat->mq_msgsize = the_core_mq->maximum_message_size; 10dec0: 8b 42 68 mov 0x68(%edx),%eax <== NOT EXECUTED 10dec3: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED omqstat->mq_maxmsg = the_core_mq->maximum_pending_messages; 10dec6: 8b 42 60 mov 0x60(%edx),%eax <== NOT EXECUTED 10dec9: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED omqstat->mq_curmsgs = the_core_mq->number_of_pending_messages; 10decc: 8b 42 64 mov 0x64(%edx),%eax <== NOT EXECUTED 10decf: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED } the_mq_fd->oflag = mqstat->mq_flags; 10ded2: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10ded4: 89 41 14 mov %eax,0x14(%ecx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10ded7: e8 ac 37 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED 10dedc: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); } 10dede: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10dee1: 5b pop %ebx <== NOT EXECUTED 10dee2: 5e pop %esi <== NOT EXECUTED 10dee3: c9 leave <== NOT EXECUTED 10dee4: c3 ret <== NOT EXECUTED 10dee5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10dee8: e8 5f 86 00 00 call 11654c <__errno> <== NOT EXECUTED 10deed: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10def3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10def8: eb e4 jmp 10dede <== NOT EXECUTED POSIX_Message_queue_Control_fd *the_mq_fd; CORE_message_queue_Control *the_core_mq; Objects_Locations location; if ( !mqstat ) rtems_set_errno_and_return_minus_one( EINVAL ); 10defa: e8 4d 86 00 00 call 11654c <__errno> <== NOT EXECUTED 10deff: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10df05: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10df0a: eb d2 jmp 10dede <== NOT EXECUTED 0010df0c : char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abstime ) { 10df0c: 55 push %ebp <== NOT EXECUTED 10df0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10df0f: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ switch ( _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ) ) { 10df12: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10df15: 50 push %eax <== NOT EXECUTED 10df16: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10df19: e8 e6 00 00 00 call 10e004 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 10df1e: 5a pop %edx <== NOT EXECUTED 10df1f: 59 pop %ecx <== NOT EXECUTED 10df20: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10df23: 0f 97 c0 seta %al <== NOT EXECUTED 10df26: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED default: /* only to silence warnings */ do_wait = TRUE; break; } return _POSIX_Message_queue_Receive_support( 10df29: ff 75 fc pushl -0x4(%ebp) <== NOT EXECUTED 10df2c: 50 push %eax <== NOT EXECUTED 10df2d: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10df30: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10df33: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10df36: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10df39: e8 0e fd ff ff call 10dc4c <_POSIX_Message_queue_Receive_support> <== NOT EXECUTED msg_len, msg_prio, do_wait, ticks ); } 10df3e: c9 leave <== NOT EXECUTED 10df3f: c3 ret <== NOT EXECUTED 0010df40 : const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abstime ) { 10df40: 55 push %ebp <== NOT EXECUTED 10df41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10df43: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ switch ( _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ) ) { 10df46: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10df49: 50 push %eax <== NOT EXECUTED 10df4a: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10df4d: e8 b2 00 00 00 call 10e004 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 10df52: 5a pop %edx <== NOT EXECUTED 10df53: 59 pop %ecx <== NOT EXECUTED 10df54: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10df57: 0f 97 c0 seta %al <== NOT EXECUTED 10df5a: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED default: /* only to silence warnings */ do_wait = TRUE; break; } return _POSIX_Message_queue_Send_support( 10df5d: ff 75 fc pushl -0x4(%ebp) <== NOT EXECUTED 10df60: 50 push %eax <== NOT EXECUTED 10df61: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10df64: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10df67: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10df6a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10df6d: e8 1a fe ff ff call 10dd8c <_POSIX_Message_queue_Send_support> <== NOT EXECUTED msg_len, msg_prio, do_wait, ticks ); } 10df72: c9 leave <== NOT EXECUTED 10df73: c3 ret <== NOT EXECUTED 0010df84 : */ int mq_unlink( const char *name ) { 10df84: 55 push %ebp <== NOT EXECUTED 10df85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10df87: 53 push %ebx <== NOT EXECUTED 10df88: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10df8b: a1 58 7c 12 00 mov 0x127c58,%eax <== NOT EXECUTED 10df90: 40 inc %eax <== NOT EXECUTED 10df91: a3 58 7c 12 00 mov %eax,0x127c58 <== NOT EXECUTED register POSIX_Message_queue_Control *the_mq; Objects_Id the_mq_id; _Thread_Disable_dispatch(); status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); 10df96: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10df99: 50 push %eax <== NOT EXECUTED 10df9a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10df9d: e8 c6 63 00 00 call 114368 <_POSIX_Message_queue_Name_to_id> <== NOT EXECUTED 10dfa2: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( status != 0 ) { 10dfa4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dfa7: 85 c0 test %eax,%eax <== NOT EXECUTED 10dfa9: 75 45 jne 10dff0 <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( status ); } the_mq = (POSIX_Message_queue_Control *) _Objects_Get_local_object( 10dfab: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 10dfae: 66 3b 05 30 80 12 00 cmp 0x128030,%ax <== NOT EXECUTED 10dfb5: 77 35 ja 10dfec <== NOT EXECUTED 10dfb7: 0f b7 d0 movzwl %ax,%edx <== NOT EXECUTED 10dfba: a1 3c 80 12 00 mov 0x12803c,%eax <== NOT EXECUTED 10dfbf: 8b 1c 90 mov (%eax,%edx,4),%ebx <== NOT EXECUTED &_POSIX_Message_queue_Information, _Objects_Get_index( the_mq_id ) ); the_mq->linked = FALSE; 10dfc2: c6 43 15 00 movb $0x0,0x15(%ebx) <== 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. * 10dfc6: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dfc9: 53 push %ebx <== NOT EXECUTED 10dfca: 68 20 80 12 00 push $0x128020 <== NOT EXECUTED 10dfcf: e8 40 2f 00 00 call 110f14 <_Objects_Namespace_remove> <== NOT EXECUTED _POSIX_Message_queue_Namespace_remove( the_mq ); _POSIX_Message_queue_Delete( the_mq ); 10dfd4: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10dfd7: e8 e4 f8 ff ff call 10d8c0 <_POSIX_Message_queue_Delete> <== NOT EXECUTED _Thread_Enable_dispatch(); 10dfdc: e8 a7 36 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED 10dfe1: 31 c0 xor %eax,%eax <== NOT EXECUTED 10dfe3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10dfe6: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10dfe9: c9 leave <== NOT EXECUTED 10dfea: c3 ret <== NOT EXECUTED 10dfeb: 90 nop <== NOT EXECUTED bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 10dfec: 31 db xor %ebx,%ebx <== NOT EXECUTED 10dfee: eb d2 jmp 10dfc2 <== NOT EXECUTED _Thread_Disable_dispatch(); status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); if ( status != 0 ) { _Thread_Enable_dispatch(); 10dff0: e8 93 36 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( status ); 10dff5: e8 52 85 00 00 call 11654c <__errno> <== NOT EXECUTED 10dffa: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10dffc: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e001: eb e3 jmp 10dfe6 <== NOT EXECUTED 001158a8 : int nanosleep( const struct timespec *rqtp, struct timespec *rmtp ) { 1158a8: 55 push %ebp <== NOT EXECUTED 1158a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1158ab: 56 push %esi <== NOT EXECUTED 1158ac: 53 push %ebx <== NOT EXECUTED 1158ad: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1158b0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Watchdog_Interval ticks; if ( !_Timespec_Is_valid( rqtp ) ) 1158b3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1158b6: 53 push %ebx <== NOT EXECUTED 1158b7: e8 68 17 00 00 call 117024 <_Timespec_Is_valid> <== NOT EXECUTED 1158bc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1158bf: 84 c0 test %al,%al <== NOT EXECUTED 1158c1: 0f 84 e1 00 00 00 je 1159a8 <== NOT EXECUTED * Return EINVAL if the delay interval is negative. * * NOTE: This behavior is beyond the POSIX specification. * FSU and GNU/Linux pthreads shares this behavior. */ if ( rqtp->tv_sec < 0 || rqtp->tv_nsec < 0 ) 1158c7: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 1158c9: 85 c0 test %eax,%eax <== NOT EXECUTED 1158cb: 0f 88 d7 00 00 00 js 1159a8 <== NOT EXECUTED 1158d1: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 1158d4: 85 c0 test %eax,%eax <== NOT EXECUTED 1158d6: 0f 88 cc 00 00 00 js 1159a8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); ticks = _Timespec_To_ticks( rqtp ); 1158dc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1158df: 53 push %ebx <== NOT EXECUTED 1158e0: e8 67 17 00 00 call 11704c <_Timespec_To_ticks> <== NOT EXECUTED 1158e5: 89 c3 mov %eax,%ebx <== NOT EXECUTED * A nanosleep for zero time is implemented as a yield. * This behavior is also beyond the POSIX specification but is * consistent with the RTEMS API and yields desirable behavior. */ if ( !ticks ) { 1158e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1158ea: 85 c0 test %eax,%eax <== NOT EXECUTED 1158ec: 75 36 jne 115924 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1158ee: a1 b8 dc 12 00 mov 0x12dcb8,%eax <== NOT EXECUTED 1158f3: 40 inc %eax <== NOT EXECUTED 1158f4: a3 b8 dc 12 00 mov %eax,0x12dcb8 <== NOT EXECUTED _Thread_Disable_dispatch(); _Thread_Yield_processor(); 1158f9: e8 4e c4 ff ff call 111d4c <_Thread_Yield_processor> <== NOT EXECUTED _Thread_Enable_dispatch(); 1158fe: e8 55 b8 ff ff call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( rmtp ) { 115903: 85 f6 test %esi,%esi <== NOT EXECUTED 115905: 0f 84 92 00 00 00 je 11599d <== NOT EXECUTED rmtp->tv_sec = 0; 11590b: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED rmtp->tv_nsec = 0; 115911: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) <== NOT EXECUTED 115918: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( ticks ) rtems_set_errno_and_return_minus_one( EINTR ); } return 0; } 11591a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11591d: 5b pop %ebx <== NOT EXECUTED 11591e: 5e pop %esi <== NOT EXECUTED 11591f: c9 leave <== NOT EXECUTED 115920: c3 ret <== NOT EXECUTED 115921: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 115924: a1 b8 dc 12 00 mov 0x12dcb8,%eax <== NOT EXECUTED 115929: 40 inc %eax <== NOT EXECUTED 11592a: a3 b8 dc 12 00 mov %eax,0x12dcb8 <== NOT EXECUTED /* * Block for the desired amount of time */ _Thread_Disable_dispatch(); _Thread_Set_state( 11592f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 115932: 68 08 00 00 10 push $0x10000008 <== NOT EXECUTED 115937: ff 35 7c dd 12 00 pushl 0x12dd7c <== NOT EXECUTED 11593d: e8 f6 c0 ff ff call 111a38 <_Thread_Set_state> <== NOT EXECUTED _Thread_Executing, STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Watchdog_Initialize( 115942: a1 7c dd 12 00 mov 0x12dd7c,%eax <== NOT EXECUTED 115947: 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. * 11594a: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 115951: c7 40 64 c0 0f 11 00 movl $0x110fc0,0x64(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 115958: 89 50 68 mov %edx,0x68(%eax) <== NOT EXECUTED * the heap 11595b: 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, 115962: 89 58 54 mov %ebx,0x54(%eax) <== NOT EXECUTED void *starting_address, size_t *size 115965: 5a pop %edx <== NOT EXECUTED 115966: 59 pop %ecx <== NOT EXECUTED 115967: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 11596a: 50 push %eax <== NOT EXECUTED 11596b: 68 9c dd 12 00 push $0x12dd9c <== NOT EXECUTED 115970: e8 af c7 ff ff call 112124 <_Watchdog_Insert> <== NOT EXECUTED _Thread_Delay_ended, _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); _Thread_Enable_dispatch(); 115975: e8 de b7 ff ff call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED /* calculate time remaining */ if ( rmtp ) { 11597a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11597d: 85 f6 test %esi,%esi <== NOT EXECUTED 11597f: 74 1c je 11599d <== NOT EXECUTED ticks -= 115981: a1 7c dd 12 00 mov 0x12dd7c,%eax <== NOT EXECUTED 115986: 03 58 5c add 0x5c(%eax),%ebx <== NOT EXECUTED 115989: 2b 58 60 sub 0x60(%eax),%ebx <== NOT EXECUTED _Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time; _Timespec_From_ticks( ticks, rmtp ); 11598c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11598f: 56 push %esi <== NOT EXECUTED 115990: 53 push %ebx <== NOT EXECUTED 115991: e8 46 16 00 00 call 116fdc <_Timespec_From_ticks> <== NOT EXECUTED /* * If there is time remaining, then we were interrupted by a signal. */ if ( ticks ) 115996: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115999: 85 db test %ebx,%ebx <== NOT EXECUTED 11599b: 75 22 jne 1159bf <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINTR ); 11599d: 31 c0 xor %eax,%eax <== NOT EXECUTED } return 0; } 11599f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1159a2: 5b pop %ebx <== NOT EXECUTED 1159a3: 5e pop %esi <== NOT EXECUTED 1159a4: c9 leave <== NOT EXECUTED 1159a5: c3 ret <== NOT EXECUTED 1159a6: 66 90 xchg %ax,%ax <== NOT EXECUTED * * NOTE: This behavior is beyond the POSIX specification. * FSU and GNU/Linux pthreads shares this behavior. */ if ( rqtp->tv_sec < 0 || rqtp->tv_nsec < 0 ) rtems_set_errno_and_return_minus_one( EINVAL ); 1159a8: e8 cf 3c 00 00 call 11967c <__errno> <== NOT EXECUTED 1159ad: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1159b3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED if ( ticks ) rtems_set_errno_and_return_minus_one( EINTR ); } return 0; } 1159b8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1159bb: 5b pop %ebx <== NOT EXECUTED 1159bc: 5e pop %esi <== NOT EXECUTED 1159bd: c9 leave <== NOT EXECUTED 1159be: c3 ret <== NOT EXECUTED /* * If there is time remaining, then we were interrupted by a signal. */ if ( ticks ) rtems_set_errno_and_return_minus_one( EINTR ); 1159bf: e8 b8 3c 00 00 call 11967c <__errno> <== NOT EXECUTED 1159c4: c7 00 04 00 00 00 movl $0x4,(%eax) <== NOT EXECUTED 1159ca: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1159cf: e9 46 ff ff ff jmp 11591a <== NOT EXECUTED 0010bd5c : /* * 3.4.2 Suspend Process Execution, P1003.1b-1993, p. 81 */ int pause( void ) { 10bd5c: 55 push %ebp <== NOT EXECUTED 10bd5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd5f: 53 push %ebx <== NOT EXECUTED 10bd60: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED sigset_t all_signals; int status; (void) sigfillset( &all_signals ); 10bd63: 8d 5d f8 lea -0x8(%ebp),%ebx <== NOT EXECUTED 10bd66: 53 push %ebx <== NOT EXECUTED 10bd67: e8 48 0a 00 00 call 10c7b4 <== NOT EXECUTED status = sigtimedwait( &all_signals, NULL, NULL ); 10bd6c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10bd6f: 6a 00 push $0x0 <== NOT EXECUTED 10bd71: 6a 00 push $0x0 <== NOT EXECUTED 10bd73: 53 push %ebx <== NOT EXECUTED 10bd74: e8 b7 0b 00 00 call 10c930 <== NOT EXECUTED return status; } 10bd79: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bd7c: c9 leave <== NOT EXECUTED 10bd7d: c3 ret <== NOT EXECUTED 0010a3a8 : int pthread_atfork( void (*prepare)(void), void (*parent)(void), void (*child)(void) ) { 10a3a8: 55 push %ebp <== NOT EXECUTED 10a3a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a3ab: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a3ae: e8 cd 76 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a3b3: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a3b9: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a3be: c9 leave <== NOT EXECUTED 10a3bf: c3 ret <== NOT EXECUTED 0010dd78 : #include int pthread_attr_destroy( pthread_attr_t *attr ) { 10dd78: 55 push %ebp <== NOT EXECUTED 10dd79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dd7b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10dd7e: 85 c0 test %eax,%eax <== NOT EXECUTED 10dd80: 74 12 je 10dd94 <== NOT EXECUTED 10dd82: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10dd84: 85 d2 test %edx,%edx <== NOT EXECUTED 10dd86: 74 0c je 10dd94 <== NOT EXECUTED return EINVAL; attr->is_initialized = FALSE; 10dd88: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 10dd8e: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10dd90: c9 leave <== NOT EXECUTED 10dd91: c3 ret <== NOT EXECUTED 10dd92: 66 90 xchg %ax,%ax <== NOT EXECUTED { if ( !attr || !attr->is_initialized ) return EINVAL; attr->is_initialized = FALSE; return 0; 10dd94: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10dd99: c9 leave <== NOT EXECUTED 10dd9a: c3 ret <== NOT EXECUTED 0010e404 : int pthread_attr_getcputime( pthread_attr_t *attr, int *clock_allowed ) { 10e404: 55 push %ebp <== NOT EXECUTED 10e405: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e407: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10e40a: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !clock_allowed ) 10e40d: 85 c0 test %eax,%eax <== NOT EXECUTED 10e40f: 74 13 je 10e424 <== NOT EXECUTED 10e411: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10e413: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10e415: 74 0d je 10e424 <== NOT EXECUTED 10e417: 85 d2 test %edx,%edx <== NOT EXECUTED 10e419: 74 09 je 10e424 <== NOT EXECUTED return EINVAL; *clock_allowed = attr->cputime_clock_allowed; 10e41b: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED 10e41e: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10e420: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10e422: c9 leave <== NOT EXECUTED 10e423: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !clock_allowed ) return EINVAL; *clock_allowed = attr->cputime_clock_allowed; return 0; 10e424: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10e429: c9 leave <== NOT EXECUTED 10e42a: c3 ret <== NOT EXECUTED 0010dd9c : int pthread_attr_getdetachstate( const pthread_attr_t *attr, int *detachstate ) { 10dd9c: 55 push %ebp <== NOT EXECUTED 10dd9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dd9f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10dda2: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !detachstate ) 10dda5: 85 c0 test %eax,%eax <== NOT EXECUTED 10dda7: 74 13 je 10ddbc <== NOT EXECUTED 10dda9: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10ddab: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ddad: 74 0d je 10ddbc <== NOT EXECUTED 10ddaf: 85 d2 test %edx,%edx <== NOT EXECUTED 10ddb1: 74 09 je 10ddbc <== NOT EXECUTED return EINVAL; *detachstate = attr->detachstate; 10ddb3: 8b 40 34 mov 0x34(%eax),%eax <== NOT EXECUTED 10ddb6: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10ddb8: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10ddba: c9 leave <== NOT EXECUTED 10ddbb: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !detachstate ) return EINVAL; *detachstate = attr->detachstate; return 0; 10ddbc: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10ddc1: c9 leave <== NOT EXECUTED 10ddc2: c3 ret <== NOT EXECUTED 0010ddc4 : int pthread_attr_getinheritsched( const pthread_attr_t *attr, int *inheritsched ) { 10ddc4: 55 push %ebp <== NOT EXECUTED 10ddc5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ddc7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ddca: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !inheritsched ) 10ddcd: 85 c0 test %eax,%eax <== NOT EXECUTED 10ddcf: 74 13 je 10dde4 <== NOT EXECUTED 10ddd1: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10ddd3: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ddd5: 74 0d je 10dde4 <== NOT EXECUTED 10ddd7: 85 d2 test %edx,%edx <== NOT EXECUTED 10ddd9: 74 09 je 10dde4 <== NOT EXECUTED return EINVAL; *inheritsched = attr->inheritsched; 10dddb: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 10ddde: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10dde0: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10dde2: c9 leave <== NOT EXECUTED 10dde3: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !inheritsched ) return EINVAL; *inheritsched = attr->inheritsched; return 0; 10dde4: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10dde9: c9 leave <== NOT EXECUTED 10ddea: c3 ret <== NOT EXECUTED 0010ddec : int pthread_attr_getschedparam( const pthread_attr_t *attr, struct sched_param *param ) { 10ddec: 55 push %ebp <== NOT EXECUTED 10dded: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ddef: 57 push %edi <== NOT EXECUTED 10ddf0: 56 push %esi <== NOT EXECUTED 10ddf1: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10ddf4: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ddf7: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED if ( !attr || !attr->is_initialized || !param ) 10ddfa: 85 c0 test %eax,%eax <== NOT EXECUTED 10ddfc: 74 1e je 10de1c <== NOT EXECUTED 10ddfe: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10de00: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10de02: 74 18 je 10de1c <== NOT EXECUTED 10de04: 85 ff test %edi,%edi <== NOT EXECUTED 10de06: 74 14 je 10de1c <== NOT EXECUTED return EINVAL; *param = attr->schedparam; 10de08: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 10de0b: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10de10: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10de12: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10de14: 5a pop %edx <== NOT EXECUTED 10de15: 5e pop %esi <== NOT EXECUTED 10de16: 5f pop %edi <== NOT EXECUTED 10de17: c9 leave <== NOT EXECUTED 10de18: c3 ret <== NOT EXECUTED 10de19: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !param ) return EINVAL; *param = attr->schedparam; return 0; 10de1c: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10de21: 5a pop %edx <== NOT EXECUTED 10de22: 5e pop %esi <== NOT EXECUTED 10de23: 5f pop %edi <== NOT EXECUTED 10de24: c9 leave <== NOT EXECUTED 10de25: c3 ret <== NOT EXECUTED 0010de28 : int pthread_attr_getschedpolicy( const pthread_attr_t *attr, int *policy ) { 10de28: 55 push %ebp <== NOT EXECUTED 10de29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10de2b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10de2e: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !policy ) 10de31: 85 c0 test %eax,%eax <== NOT EXECUTED 10de33: 74 13 je 10de48 <== NOT EXECUTED 10de35: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10de37: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10de39: 74 0d je 10de48 <== NOT EXECUTED 10de3b: 85 d2 test %edx,%edx <== NOT EXECUTED 10de3d: 74 09 je 10de48 <== NOT EXECUTED return EINVAL; *policy = attr->schedpolicy; 10de3f: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10de42: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10de44: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10de46: c9 leave <== NOT EXECUTED 10de47: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !policy ) return EINVAL; *policy = attr->schedpolicy; return 0; 10de48: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10de4d: c9 leave <== NOT EXECUTED 10de4e: c3 ret <== NOT EXECUTED 0010de50 : int pthread_attr_getscope( const pthread_attr_t *attr, int *contentionscope ) { 10de50: 55 push %ebp <== NOT EXECUTED 10de51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10de53: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10de56: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !contentionscope ) 10de59: 85 c0 test %eax,%eax <== NOT EXECUTED 10de5b: 74 13 je 10de70 <== NOT EXECUTED 10de5d: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10de5f: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10de61: 74 0d je 10de70 <== NOT EXECUTED 10de63: 85 d2 test %edx,%edx <== NOT EXECUTED 10de65: 74 09 je 10de70 <== NOT EXECUTED return EINVAL; *contentionscope = attr->contentionscope; 10de67: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10de6a: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10de6c: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10de6e: c9 leave <== NOT EXECUTED 10de6f: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !contentionscope ) return EINVAL; *contentionscope = attr->contentionscope; return 0; 10de70: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10de75: c9 leave <== NOT EXECUTED 10de76: c3 ret <== NOT EXECUTED 0010de78 : int pthread_attr_getstackaddr( const pthread_attr_t *attr, void **stackaddr ) { 10de78: 55 push %ebp <== NOT EXECUTED 10de79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10de7b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10de7e: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !stackaddr ) 10de81: 85 c0 test %eax,%eax <== NOT EXECUTED 10de83: 74 13 je 10de98 <== NOT EXECUTED 10de85: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10de87: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10de89: 74 0d je 10de98 <== NOT EXECUTED 10de8b: 85 d2 test %edx,%edx <== NOT EXECUTED 10de8d: 74 09 je 10de98 <== NOT EXECUTED return EINVAL; *stackaddr = attr->stackaddr; 10de8f: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10de92: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10de94: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10de96: c9 leave <== NOT EXECUTED 10de97: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !stackaddr ) return EINVAL; *stackaddr = attr->stackaddr; return 0; 10de98: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10de9d: c9 leave <== NOT EXECUTED 10de9e: c3 ret <== NOT EXECUTED 0010dea0 : int pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize ) { 10dea0: 55 push %ebp <== NOT EXECUTED 10dea1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dea3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10dea6: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !stacksize ) 10dea9: 85 c0 test %eax,%eax <== NOT EXECUTED 10deab: 74 13 je 10dec0 <== NOT EXECUTED 10dead: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10deaf: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10deb1: 74 0d je 10dec0 <== NOT EXECUTED 10deb3: 85 d2 test %edx,%edx <== NOT EXECUTED 10deb5: 74 09 je 10dec0 <== NOT EXECUTED return EINVAL; *stacksize = attr->stacksize; 10deb7: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10deba: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10debc: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10debe: c9 leave <== NOT EXECUTED 10debf: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !stacksize ) return EINVAL; *stacksize = attr->stacksize; return 0; 10dec0: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10dec5: c9 leave <== NOT EXECUTED 10dec6: c3 ret <== NOT EXECUTED 00110e60 : #include int pthread_attr_init( pthread_attr_t *attr ) { 110e60: 55 push %ebp <== NOT EXECUTED 110e61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110e63: 57 push %edi <== NOT EXECUTED 110e64: 56 push %esi <== NOT EXECUTED 110e65: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 110e68: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED if ( !attr ) 110e6b: 85 ff test %edi,%edi <== NOT EXECUTED 110e6d: 74 15 je 110e84 <== NOT EXECUTED return EINVAL; *attr = _POSIX_Threads_Default_attributes; 110e6f: be a0 c9 11 00 mov $0x11c9a0,%esi <== NOT EXECUTED 110e74: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 110e79: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 110e7b: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 110e7d: 5a pop %edx <== NOT EXECUTED 110e7e: 5e pop %esi <== NOT EXECUTED 110e7f: 5f pop %edi <== NOT EXECUTED 110e80: c9 leave <== NOT EXECUTED 110e81: c3 ret <== NOT EXECUTED 110e82: 66 90 xchg %ax,%ax <== NOT EXECUTED int pthread_attr_init( pthread_attr_t *attr ) { if ( !attr ) 110e84: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED return EINVAL; *attr = _POSIX_Threads_Default_attributes; return 0; } 110e89: 5a pop %edx <== NOT EXECUTED 110e8a: 5e pop %esi <== NOT EXECUTED 110e8b: 5f pop %edi <== NOT EXECUTED 110e8c: c9 leave <== NOT EXECUTED 110e8d: c3 ret <== NOT EXECUTED 0010e8dc : int pthread_attr_setcputime( pthread_attr_t *attr, int clock_allowed ) { 10e8dc: 55 push %ebp <== NOT EXECUTED 10e8dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e8df: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10e8e2: 85 c0 test %eax,%eax <== NOT EXECUTED 10e8e4: 74 0c je 10e8f2 <== NOT EXECUTED 10e8e6: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10e8e8: 85 d2 test %edx,%edx <== NOT EXECUTED 10e8ea: 74 06 je 10e8f2 <== NOT EXECUTED return EINVAL; switch ( clock_allowed ) { 10e8ec: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10e8f0: 76 0a jbe 10e8fc <== NOT EXECUTED case CLOCK_ENABLED: case CLOCK_DISABLED: attr->cputime_clock_allowed = clock_allowed; return 0; 10e8f2: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10e8f7: c9 leave <== NOT EXECUTED 10e8f8: c3 ret <== NOT EXECUTED 10e8f9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return EINVAL; switch ( clock_allowed ) { case CLOCK_ENABLED: case CLOCK_DISABLED: attr->cputime_clock_allowed = clock_allowed; 10e8fc: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10e8ff: 89 50 30 mov %edx,0x30(%eax) <== NOT EXECUTED 10e902: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; default: return EINVAL; } } 10e904: c9 leave <== NOT EXECUTED 10e905: c3 ret <== NOT EXECUTED 0010def8 : int pthread_attr_setdetachstate( pthread_attr_t *attr, int detachstate ) { 10def8: 55 push %ebp <== NOT EXECUTED 10def9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10defb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10defe: 85 c0 test %eax,%eax <== NOT EXECUTED 10df00: 74 0c je 10df0e <== NOT EXECUTED 10df02: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10df04: 85 d2 test %edx,%edx <== NOT EXECUTED 10df06: 74 06 je 10df0e <== NOT EXECUTED return EINVAL; switch ( detachstate ) { 10df08: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10df0c: 76 0a jbe 10df18 <== NOT EXECUTED case PTHREAD_CREATE_DETACHED: case PTHREAD_CREATE_JOINABLE: attr->detachstate = detachstate; return 0; 10df0e: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10df13: c9 leave <== NOT EXECUTED 10df14: c3 ret <== NOT EXECUTED 10df15: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return EINVAL; switch ( detachstate ) { case PTHREAD_CREATE_DETACHED: case PTHREAD_CREATE_JOINABLE: attr->detachstate = detachstate; 10df18: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10df1b: 89 50 34 mov %edx,0x34(%eax) <== NOT EXECUTED 10df1e: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; default: return EINVAL; } } 10df20: c9 leave <== NOT EXECUTED 10df21: c3 ret <== NOT EXECUTED 00110e90 : int pthread_attr_setinheritsched( pthread_attr_t *attr, int inheritsched ) { 110e90: 55 push %ebp <== NOT EXECUTED 110e91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110e93: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 110e96: 85 d2 test %edx,%edx <== NOT EXECUTED 110e98: 74 22 je 110ebc <== NOT EXECUTED 110e9a: 8b 02 mov (%edx),%eax <== NOT EXECUTED 110e9c: 85 c0 test %eax,%eax <== NOT EXECUTED 110e9e: 74 1c je 110ebc <== NOT EXECUTED return EINVAL; switch ( inheritsched ) { 110ea0: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 110ea3: 48 dec %eax <== NOT EXECUTED 110ea4: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 110ea7: 76 07 jbe 110eb0 <== NOT EXECUTED 110ea9: b8 86 00 00 00 mov $0x86,%eax <== NOT EXECUTED return 0; default: return ENOTSUP; } } 110eae: c9 leave <== NOT EXECUTED 110eaf: c3 ret <== NOT EXECUTED return EINVAL; switch ( inheritsched ) { case PTHREAD_INHERIT_SCHED: case PTHREAD_EXPLICIT_SCHED: attr->inheritsched = inheritsched; 110eb0: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 110eb3: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED 110eb6: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; default: return ENOTSUP; } } 110eb8: c9 leave <== NOT EXECUTED 110eb9: c3 ret <== NOT EXECUTED 110eba: 66 90 xchg %ax,%ax <== NOT EXECUTED switch ( inheritsched ) { case PTHREAD_INHERIT_SCHED: case PTHREAD_EXPLICIT_SCHED: attr->inheritsched = inheritsched; return 0; 110ebc: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return ENOTSUP; } } 110ec1: c9 leave <== NOT EXECUTED 110ec2: c3 ret <== NOT EXECUTED 0010df58 : int pthread_attr_setschedparam( pthread_attr_t *attr, const struct sched_param *param ) { 10df58: 55 push %ebp <== NOT EXECUTED 10df59: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10df5b: 57 push %edi <== NOT EXECUTED 10df5c: 56 push %esi <== NOT EXECUTED 10df5d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10df60: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED if ( !attr || !attr->is_initialized || !param ) 10df63: 85 c0 test %eax,%eax <== NOT EXECUTED 10df65: 74 1d je 10df84 <== NOT EXECUTED 10df67: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10df69: 85 d2 test %edx,%edx <== NOT EXECUTED 10df6b: 74 17 je 10df84 <== NOT EXECUTED 10df6d: 85 f6 test %esi,%esi <== NOT EXECUTED 10df6f: 74 13 je 10df84 <== NOT EXECUTED return EINVAL; attr->schedparam = *param; 10df71: 8d 78 18 lea 0x18(%eax),%edi <== NOT EXECUTED 10df74: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10df79: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10df7b: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10df7d: 5e pop %esi <== NOT EXECUTED 10df7e: 5f pop %edi <== NOT EXECUTED 10df7f: c9 leave <== NOT EXECUTED 10df80: c3 ret <== NOT EXECUTED 10df81: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !param ) return EINVAL; attr->schedparam = *param; return 0; 10df84: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10df89: 5e pop %esi <== NOT EXECUTED 10df8a: 5f pop %edi <== NOT EXECUTED 10df8b: c9 leave <== NOT EXECUTED 10df8c: c3 ret <== NOT EXECUTED 0010df90 : int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { 10df90: 55 push %ebp <== NOT EXECUTED 10df91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10df93: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10df96: 85 c0 test %eax,%eax <== NOT EXECUTED 10df98: 74 22 je 10dfbc <== NOT EXECUTED 10df9a: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10df9c: 85 d2 test %edx,%edx <== NOT EXECUTED 10df9e: 74 1c je 10dfbc <== NOT EXECUTED return EINVAL; switch ( policy ) { 10dfa0: 83 7d 0c 03 cmpl $0x3,0xc(%ebp) <== NOT EXECUTED 10dfa4: 76 0a jbe 10dfb0 <== NOT EXECUTED 10dfa6: b8 86 00 00 00 mov $0x86,%eax <== NOT EXECUTED return 0; default: return ENOTSUP; } } 10dfab: c9 leave <== NOT EXECUTED 10dfac: c3 ret <== NOT EXECUTED 10dfad: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED switch ( policy ) { case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: case SCHED_SPORADIC: attr->schedpolicy = policy; 10dfb0: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10dfb3: 89 50 14 mov %edx,0x14(%eax) <== NOT EXECUTED 10dfb6: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; default: return ENOTSUP; } } 10dfb8: c9 leave <== NOT EXECUTED 10dfb9: c3 ret <== NOT EXECUTED 10dfba: 66 90 xchg %ax,%ax <== NOT EXECUTED case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: case SCHED_SPORADIC: attr->schedpolicy = policy; return 0; 10dfbc: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return ENOTSUP; } } 10dfc1: c9 leave <== NOT EXECUTED 10dfc2: c3 ret <== NOT EXECUTED 0010dfc4 : int pthread_attr_setscope( pthread_attr_t *attr, int contentionscope ) { 10dfc4: 55 push %ebp <== NOT EXECUTED 10dfc5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dfc7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10dfca: 85 c0 test %eax,%eax <== NOT EXECUTED 10dfcc: 74 20 je 10dfee <== NOT EXECUTED 10dfce: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10dfd0: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10dfd2: 74 1a je 10dfee <== NOT EXECUTED return EINVAL; switch ( contentionscope ) { 10dfd4: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10dfd7: 85 d2 test %edx,%edx <== NOT EXECUTED 10dfd9: 75 0d jne 10dfe8 <== NOT EXECUTED case PTHREAD_SCOPE_PROCESS: attr->contentionscope = contentionscope; 10dfdb: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) <== NOT EXECUTED 10dfe2: 31 c0 xor %eax,%eax <== NOT EXECUTED return ENOTSUP; default: return EINVAL; } } 10dfe4: c9 leave <== NOT EXECUTED 10dfe5: c3 ret <== NOT EXECUTED 10dfe6: 66 90 xchg %ax,%ax <== NOT EXECUTED ) { if ( !attr || !attr->is_initialized ) return EINVAL; switch ( contentionscope ) { 10dfe8: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10dfec: 74 0a je 10dff8 <== NOT EXECUTED case PTHREAD_SCOPE_PROCESS: attr->contentionscope = contentionscope; return 0; 10dfee: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED return ENOTSUP; default: return EINVAL; } } 10dff3: c9 leave <== NOT EXECUTED 10dff4: c3 ret <== NOT EXECUTED 10dff5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { if ( !attr || !attr->is_initialized ) return EINVAL; switch ( contentionscope ) { 10dff8: b8 86 00 00 00 mov $0x86,%eax <== NOT EXECUTED return ENOTSUP; default: return EINVAL; } } 10dffd: c9 leave <== NOT EXECUTED 10dffe: c3 ret <== NOT EXECUTED 0010e000 : int pthread_attr_setstackaddr( pthread_attr_t *attr, void *stackaddr ) { 10e000: 55 push %ebp <== NOT EXECUTED 10e001: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e003: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10e006: 85 c0 test %eax,%eax <== NOT EXECUTED 10e008: 74 12 je 10e01c <== NOT EXECUTED 10e00a: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10e00c: 85 d2 test %edx,%edx <== NOT EXECUTED 10e00e: 74 0c je 10e01c <== NOT EXECUTED return EINVAL; attr->stackaddr = stackaddr; 10e010: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10e013: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 10e016: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10e018: c9 leave <== NOT EXECUTED 10e019: c3 ret <== NOT EXECUTED 10e01a: 66 90 xchg %ax,%ax <== NOT EXECUTED { if ( !attr || !attr->is_initialized ) return EINVAL; attr->stackaddr = stackaddr; return 0; 10e01c: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10e021: c9 leave <== NOT EXECUTED 10e022: c3 ret <== NOT EXECUTED 00110ec4 : int pthread_attr_setstacksize( pthread_attr_t *attr, size_t stacksize ) { 110ec4: 55 push %ebp <== NOT EXECUTED 110ec5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110ec7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 110eca: 85 d2 test %edx,%edx <== NOT EXECUTED 110ecc: 74 1e je 110eec <== NOT EXECUTED 110ece: 8b 02 mov (%edx),%eax <== NOT EXECUTED 110ed0: 85 c0 test %eax,%eax <== NOT EXECUTED 110ed2: 74 18 je 110eec <== NOT EXECUTED return EINVAL; if (stacksize < PTHREAD_MINIMUM_STACK_SIZE) 110ed4: a1 14 ee 11 00 mov 0x11ee14,%eax <== NOT EXECUTED 110ed9: d1 e0 shl %eax <== NOT EXECUTED 110edb: 3b 45 0c cmp 0xc(%ebp),%eax <== NOT EXECUTED 110ede: 77 03 ja 110ee3 <== NOT EXECUTED attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE; else attr->stacksize = stacksize; 110ee0: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 110ee3: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED 110ee6: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 110ee8: c9 leave <== NOT EXECUTED 110ee9: c3 ret <== NOT EXECUTED 110eea: 66 90 xchg %ax,%ax <== NOT EXECUTED return EINVAL; if (stacksize < PTHREAD_MINIMUM_STACK_SIZE) attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE; else attr->stacksize = stacksize; 110eec: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED return 0; } 110ef1: c9 leave <== NOT EXECUTED 110ef2: c3 ret <== NOT EXECUTED 0010a400 : */ int pthread_barrier_destroy( pthread_barrier_t *barrier ) { 10a400: 55 push %ebp <== NOT EXECUTED 10a401: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a403: 53 push %ebx <== NOT EXECUTED 10a404: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10a407: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_Barrier_Control *the_barrier = NULL; Objects_Locations location; if ( !barrier ) 10a40a: 85 d2 test %edx,%edx <== NOT EXECUTED 10a40c: 74 36 je 10a444 <== 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 10a40e: 50 push %eax <== NOT EXECUTED 10a40f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a412: 50 push %eax <== NOT EXECUTED 10a413: ff 32 pushl (%edx) <== NOT EXECUTED 10a415: 68 60 13 12 00 push $0x121360 <== NOT EXECUTED 10a41a: e8 a9 28 00 00 call 10ccc8 <_Objects_Get> <== NOT EXECUTED 10a41f: 89 c3 mov %eax,%ebx <== NOT EXECUTED return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); switch ( location ) { 10a421: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a424: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10a427: 85 c0 test %eax,%eax <== NOT EXECUTED 10a429: 75 19 jne 10a444 <== NOT EXECUTED case OBJECTS_LOCAL: if ( the_barrier->Barrier.number_of_waiting_threads != 0 ) { 10a42b: 8b 4b 58 mov 0x58(%ebx),%ecx <== NOT EXECUTED 10a42e: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a430: 74 1e je 10a450 <== NOT EXECUTED _Thread_Enable_dispatch(); 10a432: e8 d5 30 00 00 call 10d50c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a437: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a43c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a43f: c9 leave <== NOT EXECUTED 10a440: c3 ret <== NOT EXECUTED 10a441: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Objects_Close( &_POSIX_Barrier_Information, &the_barrier->Object ); _POSIX_Barrier_Free( the_barrier ); _Thread_Enable_dispatch(); return 0; 10a444: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a449: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a44c: c9 leave <== NOT EXECUTED 10a44d: c3 ret <== NOT EXECUTED 10a44e: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( the_barrier->Barrier.number_of_waiting_threads != 0 ) { _Thread_Enable_dispatch(); return EBUSY; } _Objects_Close( &_POSIX_Barrier_Information, &the_barrier->Object ); 10a450: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a453: 53 push %ebx <== NOT EXECUTED 10a454: 68 60 13 12 00 push $0x121360 <== NOT EXECUTED 10a459: e8 f6 23 00 00 call 10c854 <_Objects_Close> <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon * @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 * 10a45e: 58 pop %eax <== NOT EXECUTED 10a45f: 5a pop %edx <== NOT EXECUTED 10a460: 53 push %ebx <== NOT EXECUTED 10a461: 68 60 13 12 00 push $0x121360 <== NOT EXECUTED 10a466: e8 29 27 00 00 call 10cb94 <_Objects_Free> <== NOT EXECUTED _POSIX_Barrier_Free( the_barrier ); _Thread_Enable_dispatch(); 10a46b: e8 9c 30 00 00 call 10d50c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a470: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a472: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a475: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a478: c9 leave <== NOT EXECUTED 10a479: c3 ret <== NOT EXECUTED 0010a47c : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 10a47c: 55 push %ebp <== NOT EXECUTED 10a47d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a47f: 57 push %edi <== NOT EXECUTED 10a480: 56 push %esi <== NOT EXECUTED 10a481: 53 push %ebx <== NOT EXECUTED 10a482: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10a485: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10a488: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 10a48b: 85 ff test %edi,%edi <== NOT EXECUTED 10a48d: 0f 84 89 00 00 00 je 10a51c <== NOT EXECUTED return EINVAL; if ( count == 0 ) 10a493: 85 f6 test %esi,%esi <== NOT EXECUTED 10a495: 0f 84 81 00 00 00 je 10a51c <== NOT EXECUTED return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10a49b: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10a49e: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a4a0: 0f 84 92 00 00 00 je 10a538 <== NOT EXECUTED 10a4a6: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 10a4a9: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10a4ab: 85 d2 test %edx,%edx <== NOT EXECUTED 10a4ad: 74 6d je 10a51c <== NOT EXECUTED return EINVAL; switch ( the_attr->process_shared ) { 10a4af: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10a4b2: 85 c0 test %eax,%eax <== NOT EXECUTED 10a4b4: 75 66 jne 10a51c <== NOT EXECUTED } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 10a4b6: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) <== NOT EXECUTED the_attributes.maximum_count = count; 10a4bd: 89 75 f0 mov %esi,-0x10(%ebp) <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a4c0: a1 18 0f 12 00 mov 0x120f18,%eax <== NOT EXECUTED 10a4c5: 40 inc %eax <== NOT EXECUTED 10a4c6: a3 18 0f 12 00 mov %eax,0x120f18 <== NOT EXECUTED */ /**@{*/ #ifdef __cplusplus extern "C" { #endif 10a4cb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a4ce: 68 60 13 12 00 push $0x121360 <== NOT EXECUTED 10a4d3: e8 fc 22 00 00 call 10c7d4 <_Objects_Allocate> <== NOT EXECUTED 10a4d8: 89 c3 mov %eax,%ebx <== NOT EXECUTED */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 10a4da: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a4dd: 85 c0 test %eax,%eax <== NOT EXECUTED 10a4df: 74 4b je 10a52c <== NOT EXECUTED _Thread_Enable_dispatch(); return EAGAIN; } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 10a4e1: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a4e4: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10a4e7: 50 push %eax <== NOT EXECUTED 10a4e8: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10a4eb: 50 push %eax <== NOT EXECUTED 10a4ec: e8 3f 1a 00 00 call 10bf30 <_CORE_barrier_Initialize> <== NOT EXECUTED 10a4f1: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10a4f4: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10a4f7: a1 7c 13 12 00 mov 0x12137c,%eax <== NOT EXECUTED 10a4fc: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10a4ff: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED ); /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; 10a506: 89 0f mov %ecx,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a508: e8 ff 2f 00 00 call 10d50c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a50d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a50f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10a512: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a515: 5b pop %ebx <== NOT EXECUTED 10a516: 5e pop %esi <== NOT EXECUTED 10a517: 5f pop %edi <== NOT EXECUTED 10a518: c9 leave <== NOT EXECUTED 10a519: c3 ret <== NOT EXECUTED 10a51a: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; _Thread_Enable_dispatch(); return 0; 10a51c: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10a521: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a524: 5b pop %ebx <== NOT EXECUTED 10a525: 5e pop %esi <== NOT EXECUTED 10a526: 5f pop %edi <== NOT EXECUTED 10a527: c9 leave <== NOT EXECUTED 10a528: c3 ret <== NOT EXECUTED 10a529: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { _Thread_Enable_dispatch(); 10a52c: e8 db 2f 00 00 call 10d50c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a531: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 10a536: eb e9 jmp 10a521 <== NOT EXECUTED * If the user passed in NULL, use the default attributes */ if ( attr ) { the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 10a538: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a53b: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED 10a53e: 53 push %ebx <== NOT EXECUTED 10a53f: e8 70 fe ff ff call 10a3b4 <== NOT EXECUTED 10a544: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a546: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a549: e9 5b ff ff ff jmp 10a4a9 <== NOT EXECUTED 0010a550 : */ int pthread_barrier_wait( pthread_barrier_t *barrier ) { 10a550: 55 push %ebp <== NOT EXECUTED 10a551: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a553: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10a556: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_Barrier_Control *the_barrier = NULL; Objects_Locations location; if ( !barrier ) 10a559: 85 d2 test %edx,%edx <== NOT EXECUTED 10a55b: 74 4f je 10a5ac <== 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 10a55d: 51 push %ecx <== NOT EXECUTED 10a55e: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10a561: 50 push %eax <== NOT EXECUTED 10a562: ff 32 pushl (%edx) <== NOT EXECUTED 10a564: 68 60 13 12 00 push $0x121360 <== NOT EXECUTED 10a569: e8 5a 27 00 00 call 10ccc8 <_Objects_Get> <== NOT EXECUTED return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); switch ( location ) { 10a56e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a571: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10a574: 85 d2 test %edx,%edx <== NOT EXECUTED 10a576: 75 34 jne 10a5ac <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_barrier_Wait( 10a578: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a57b: 6a 00 push $0x0 <== NOT EXECUTED 10a57d: 6a 00 push $0x0 <== NOT EXECUTED 10a57f: 6a 01 push $0x1 <== NOT EXECUTED 10a581: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10a584: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10a587: 50 push %eax <== NOT EXECUTED 10a588: e8 d7 19 00 00 call 10bf64 <_CORE_barrier_Wait> <== NOT EXECUTED the_barrier->Object.id, TRUE, 0, NULL ); _Thread_Enable_dispatch(); 10a58d: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10a590: e8 77 2f 00 00 call 10d50c <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_Barrier_Translate_core_barrier_return_code( 10a595: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a598: a1 dc 0f 12 00 mov 0x120fdc,%eax <== NOT EXECUTED 10a59d: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10a5a0: e8 4f 5c 00 00 call 1101f4 <_POSIX_Barrier_Translate_core_barrier_return_code> <== NOT EXECUTED 10a5a5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a5a8: c9 leave <== NOT EXECUTED 10a5a9: c3 ret <== NOT EXECUTED 10a5aa: 66 90 xchg %ax,%ax <== NOT EXECUTED TRUE, 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_Barrier_Translate_core_barrier_return_code( 10a5ac: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a5b1: c9 leave <== NOT EXECUTED 10a5b2: c3 ret <== NOT EXECUTED 0010a36c : */ int pthread_barrierattr_destroy( pthread_barrierattr_t *attr ) { 10a36c: 55 push %ebp <== NOT EXECUTED 10a36d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a36f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || attr->is_initialized == FALSE ) 10a372: 85 c0 test %eax,%eax <== NOT EXECUTED 10a374: 74 12 je 10a388 <== NOT EXECUTED 10a376: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10a378: 85 d2 test %edx,%edx <== NOT EXECUTED 10a37a: 74 0c je 10a388 <== NOT EXECUTED return EINVAL; attr->is_initialized = FALSE; 10a37c: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 10a382: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10a384: c9 leave <== NOT EXECUTED 10a385: c3 ret <== NOT EXECUTED 10a386: 66 90 xchg %ax,%ax <== NOT EXECUTED { if ( !attr || attr->is_initialized == FALSE ) return EINVAL; attr->is_initialized = FALSE; return 0; 10a388: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10a38d: c9 leave <== NOT EXECUTED 10a38e: c3 ret <== NOT EXECUTED 0010a390 : int pthread_barrierattr_getpshared( const pthread_barrierattr_t *attr, int *pshared ) { 10a390: 55 push %ebp <== NOT EXECUTED 10a391: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a393: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr ) 10a396: 85 c0 test %eax,%eax <== NOT EXECUTED 10a398: 74 12 je 10a3ac <== NOT EXECUTED return EINVAL; if ( !attr->is_initialized ) 10a39a: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10a39c: 85 d2 test %edx,%edx <== NOT EXECUTED 10a39e: 74 0c je 10a3ac <== NOT EXECUTED return EINVAL; *pshared = attr->process_shared; 10a3a0: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10a3a3: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10a3a6: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10a3a8: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10a3aa: c9 leave <== NOT EXECUTED 10a3ab: c3 ret <== NOT EXECUTED if ( !attr->is_initialized ) return EINVAL; *pshared = attr->process_shared; return 0; 10a3ac: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10a3b1: c9 leave <== NOT EXECUTED 10a3b2: c3 ret <== NOT EXECUTED 0010a3b4 : */ int pthread_barrierattr_init( pthread_barrierattr_t *attr ) { 10a3b4: 55 push %ebp <== NOT EXECUTED 10a3b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a3b7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr ) 10a3ba: 85 c0 test %eax,%eax <== NOT EXECUTED 10a3bc: 74 12 je 10a3d0 <== NOT EXECUTED return EINVAL; attr->is_initialized = TRUE; 10a3be: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED attr->process_shared = PTHREAD_PROCESS_PRIVATE; 10a3c4: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED 10a3cb: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10a3cd: c9 leave <== NOT EXECUTED 10a3ce: c3 ret <== NOT EXECUTED 10a3cf: 90 nop <== NOT EXECUTED int pthread_barrierattr_init( pthread_barrierattr_t *attr ) { if ( !attr ) 10a3d0: b0 16 mov $0x16,%al <== NOT EXECUTED return EINVAL; attr->is_initialized = TRUE; attr->process_shared = PTHREAD_PROCESS_PRIVATE; return 0; } 10a3d2: c9 leave <== NOT EXECUTED 10a3d3: c3 ret <== NOT EXECUTED 0010a3d4 : int pthread_barrierattr_setpshared( pthread_barrierattr_t *attr, int pshared ) { 10a3d4: 55 push %ebp <== NOT EXECUTED 10a3d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a3d7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr ) 10a3da: 85 c0 test %eax,%eax <== NOT EXECUTED 10a3dc: 74 0c je 10a3ea <== NOT EXECUTED return EINVAL; if ( !attr->is_initialized ) 10a3de: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10a3e0: 85 d2 test %edx,%edx <== NOT EXECUTED 10a3e2: 74 06 je 10a3ea <== NOT EXECUTED return EINVAL; switch ( pshared ) { 10a3e4: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10a3e8: 76 0a jbe 10a3f4 <== NOT EXECUTED case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; return 0; 10a3ea: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10a3ef: c9 leave <== NOT EXECUTED 10a3f0: c3 ret <== NOT EXECUTED 10a3f1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return EINVAL; switch ( pshared ) { case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10a3f4: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10a3f7: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 10a3fa: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; default: return EINVAL; } } 10a3fc: c9 leave <== NOT EXECUTED 10a3fd: c3 ret <== NOT EXECUTED 00109bac : */ int pthread_cancel( pthread_t thread ) { 109bac: 55 push %ebp <== NOT EXECUTED 109bad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109baf: 53 push %ebx <== NOT EXECUTED 109bb0: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) 109bb3: a1 b8 22 12 00 mov 0x1222b8,%eax <== NOT EXECUTED 109bb8: 85 c0 test %eax,%eax <== NOT EXECUTED 109bba: 74 0c je 109bc8 <== NOT EXECUTED 109bbc: b8 47 00 00 00 mov $0x47,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 109bc1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109bc4: c9 leave <== NOT EXECUTED 109bc5: c3 ret <== NOT EXECUTED 109bc6: 66 90 xchg %ax,%ax <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 109bc8: 53 push %ebx <== NOT EXECUTED 109bc9: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109bcc: 50 push %eax <== NOT EXECUTED 109bcd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109bd0: 68 e0 24 12 00 push $0x1224e0 <== NOT EXECUTED 109bd5: e8 4e 29 00 00 call 10c528 <_Objects_Get> <== NOT EXECUTED 109bda: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( _ISR_Is_in_progress() ) return EPROTO; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 109bdc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109bdf: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 109be2: 85 c9 test %ecx,%ecx <== NOT EXECUTED 109be4: 74 0a je 109bf0 <== NOT EXECUTED 109be6: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 109beb: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109bee: c9 leave <== NOT EXECUTED 109bef: c3 ret <== NOT EXECUTED the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { case OBJECTS_LOCAL: thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 109bf0: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax <== NOT EXECUTED thread_support->cancelation_requested = 1; 109bf6: c7 80 d4 00 00 00 01 movl $0x1,0xd4(%eax) <== NOT EXECUTED 109bfd: 00 00 00 <== NOT EXECUTED if (thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 109c00: 8b 90 cc 00 00 00 mov 0xcc(%eax),%edx <== NOT EXECUTED 109c06: 85 d2 test %edx,%edx <== NOT EXECUTED 109c08: 75 09 jne 109c13 <== NOT EXECUTED 109c0a: 83 b8 d0 00 00 00 01 cmpl $0x1,0xd0(%eax) <== NOT EXECUTED 109c11: 74 0d je 109c20 <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS) cancel = true; _Thread_Enable_dispatch(); 109c13: e8 54 31 00 00 call 10cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED 109c18: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 109c1a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109c1d: c9 leave <== NOT EXECUTED 109c1e: c3 ret <== NOT EXECUTED 109c1f: 90 nop <== NOT EXECUTED if (thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS) cancel = true; _Thread_Enable_dispatch(); 109c20: e8 47 31 00 00 call 10cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED if ( cancel ) _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); 109c25: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109c28: 6a ff push $0xffffffff <== NOT EXECUTED 109c2a: 53 push %ebx <== NOT EXECUTED 109c2b: e8 38 03 00 00 call 109f68 <_POSIX_Thread_Exit> <== NOT EXECUTED 109c30: 31 c0 xor %eax,%eax <== NOT EXECUTED 109c32: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109c35: eb 8a jmp 109bc1 <== NOT EXECUTED 0010a07c : */ void pthread_cleanup_pop( int execute ) { 10a07c: 55 push %ebp <== NOT EXECUTED 10a07d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a07f: 57 push %edi <== NOT EXECUTED 10a080: 56 push %esi <== NOT EXECUTED 10a081: 53 push %ebx <== NOT EXECUTED 10a082: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10a085: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a088: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED POSIX_Cancel_Handler_control tmp_handler; Chain_Control *handler_stack; POSIX_API_Control *thread_support; ISR_Level level; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a08b: a1 7c 2f 12 00 mov 0x122f7c,%eax <== NOT EXECUTED 10a090: 8b 90 f8 00 00 00 mov 0xf8(%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 10a096: a1 b8 2e 12 00 mov 0x122eb8,%eax <== NOT EXECUTED 10a09b: 40 inc %eax <== NOT EXECUTED 10a09c: a3 b8 2e 12 00 mov %eax,0x122eb8 <== NOT EXECUTED * ensure that we do not get prempted and deleted while we are holding * memory that needs to be freed. */ _Thread_Disable_dispatch(); _ISR_Disable( level ); 10a0a1: 9c pushf <== NOT EXECUTED 10a0a2: fa cli <== NOT EXECUTED 10a0a3: 5f pop %edi <== 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 10a0a4: 8d 82 dc 00 00 00 lea 0xdc(%edx),%eax <== NOT EXECUTED if ( _Chain_Is_empty( handler_stack ) ) { 10a0aa: 39 82 d8 00 00 00 cmp %eax,0xd8(%edx) <== NOT EXECUTED 10a0b0: 74 5a je 10a10c <== NOT EXECUTED _Thread_Enable_dispatch(); _ISR_Enable( level ); return; } handler = (POSIX_Cancel_Handler_control *) 10a0b2: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10a0b5: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED 10a0b8: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10a0ba: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10a0bd: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10a0c0: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 10a0c2: 57 push %edi <== NOT EXECUTED 10a0c3: 9d popf <== NOT EXECUTED tmp_handler = *handler; 10a0c4: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 10a0c7: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10a0cc: 8b 75 d8 mov -0x28(%ebp),%esi <== NOT EXECUTED 10a0cf: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10a0d1: 8b 5d ec mov -0x14(%ebp),%ebx <== NOT EXECUTED 10a0d4: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED _Workspace_Free( handler ); 10a0d7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a0da: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 10a0dd: e8 9a 46 00 00 call 10e77c <_Workspace_Free> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a0e2: e8 d9 34 00 00 call 10d5c0 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( execute ) 10a0e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a0ea: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10a0ed: 85 c0 test %eax,%eax <== NOT EXECUTED 10a0ef: 75 0b jne 10a0fc <== NOT EXECUTED (*tmp_handler.routine)( tmp_handler.arg ); } 10a0f1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a0f4: 5b pop %ebx <== NOT EXECUTED 10a0f5: 5e pop %esi <== NOT EXECUTED 10a0f6: 5f pop %edi <== NOT EXECUTED 10a0f7: c9 leave <== NOT EXECUTED 10a0f8: c3 ret <== NOT EXECUTED 10a0f9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Workspace_Free( handler ); _Thread_Enable_dispatch(); if ( execute ) (*tmp_handler.routine)( tmp_handler.arg ); 10a0fc: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED 10a0ff: 89 d9 mov %ebx,%ecx <== NOT EXECUTED } 10a101: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a104: 5b pop %ebx <== NOT EXECUTED 10a105: 5e pop %esi <== NOT EXECUTED 10a106: 5f pop %edi <== NOT EXECUTED 10a107: c9 leave <== NOT EXECUTED _Workspace_Free( handler ); _Thread_Enable_dispatch(); if ( execute ) (*tmp_handler.routine)( tmp_handler.arg ); 10a108: ff e1 jmp *%ecx <== NOT EXECUTED 10a10a: 66 90 xchg %ax,%ax <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Disable( level ); if ( _Chain_Is_empty( handler_stack ) ) { _Thread_Enable_dispatch(); 10a10c: e8 af 34 00 00 call 10d5c0 <_Thread_Enable_dispatch> <== NOT EXECUTED _ISR_Enable( level ); 10a111: 57 push %edi <== NOT EXECUTED 10a112: 9d popf <== NOT EXECUTED _Thread_Enable_dispatch(); if ( execute ) (*tmp_handler.routine)( tmp_handler.arg ); } 10a113: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a116: 5b pop %ebx <== NOT EXECUTED 10a117: 5e pop %esi <== NOT EXECUTED 10a118: 5f pop %edi <== NOT EXECUTED 10a119: c9 leave <== NOT EXECUTED 10a11a: c3 ret <== NOT EXECUTED 0010a11c : void pthread_cleanup_push( void (*routine)( void * ), void *arg ) { 10a11c: 55 push %ebp <== NOT EXECUTED 10a11d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a11f: 56 push %esi <== NOT EXECUTED 10a120: 53 push %ebx <== NOT EXECUTED 10a121: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a124: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * The POSIX standard does not address what to do when the routine * is NULL. It also does not address what happens when we cannot * allocate memory or anything else bad happens. */ if ( !routine ) 10a127: 85 db test %ebx,%ebx <== NOT EXECUTED 10a129: 74 4d je 10a178 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a12b: a1 b8 2e 12 00 mov 0x122eb8,%eax <== NOT EXECUTED 10a130: 40 inc %eax <== NOT EXECUTED 10a131: a3 b8 2e 12 00 mov %eax,0x122eb8 <== NOT EXECUTED return; _Thread_Disable_dispatch(); handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) ); 10a136: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a139: 6a 10 push $0x10 <== NOT EXECUTED 10a13b: e8 54 46 00 00 call 10e794 <_Workspace_Allocate> <== NOT EXECUTED 10a140: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( handler ) { 10a142: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a145: 85 c0 test %eax,%eax <== NOT EXECUTED 10a147: 74 23 je 10a16c <== NOT EXECUTED thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; handler_stack = &thread_support->Cancellation_Handlers; 10a149: a1 7c 2f 12 00 mov 0x122f7c,%eax <== NOT EXECUTED 10a14e: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax <== NOT EXECUTED 10a154: 05 d8 00 00 00 add $0xd8,%eax <== NOT EXECUTED handler->routine = routine; 10a159: 89 5a 08 mov %ebx,0x8(%edx) <== NOT EXECUTED handler->arg = arg; 10a15c: 89 72 0c mov %esi,0xc(%edx) <== NOT EXECUTED _Chain_Append( handler_stack, &handler->Node ); 10a15f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a162: 52 push %edx <== NOT EXECUTED 10a163: 50 push %eax <== NOT EXECUTED 10a164: e8 e7 1e 00 00 call 10c050 <_Chain_Append> <== NOT EXECUTED 10a169: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _Thread_Enable_dispatch(); } 10a16c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a16f: 5b pop %ebx <== NOT EXECUTED 10a170: 5e pop %esi <== NOT EXECUTED 10a171: c9 leave <== NOT EXECUTED handler->routine = routine; handler->arg = arg; _Chain_Append( handler_stack, &handler->Node ); } _Thread_Enable_dispatch(); 10a172: e9 49 34 00 00 jmp 10d5c0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a177: 90 nop <== NOT EXECUTED } 10a178: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a17b: 5b pop %ebx <== NOT EXECUTED 10a17c: 5e pop %esi <== NOT EXECUTED 10a17d: c9 leave <== NOT EXECUTED 10a17e: c3 ret <== NOT EXECUTED 0010ad44 : */ int pthread_cond_broadcast( pthread_cond_t *cond ) { 10ad44: 55 push %ebp <== NOT EXECUTED 10ad45: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad47: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _POSIX_Condition_variables_Signal_support( cond, TRUE ); 10ad4a: 6a 01 push $0x1 <== NOT EXECUTED 10ad4c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ad4f: e8 98 01 00 00 call 10aeec <_POSIX_Condition_variables_Signal_support> <== NOT EXECUTED } 10ad54: c9 leave <== NOT EXECUTED 10ad55: c3 ret <== NOT EXECUTED 0010ad58 : */ int pthread_cond_destroy( pthread_cond_t *cond ) { 10ad58: 55 push %ebp <== NOT EXECUTED 10ad59: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad5b: 53 push %ebx <== NOT EXECUTED 10ad5c: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED POSIX_Condition_variables_Control *the_cond; Objects_Locations location; the_cond = _POSIX_Condition_variables_Get( cond, &location ); 10ad5f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10ad62: 50 push %eax <== NOT EXECUTED 10ad63: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ad66: e8 65 00 00 00 call 10add0 <_POSIX_Condition_variables_Get> <== NOT EXECUTED 10ad6b: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch ( location ) { 10ad6d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad70: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 10ad73: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ad75: 75 25 jne 10ad9c <== NOT EXECUTED case OBJECTS_LOCAL: if ( _Thread_queue_First( &the_cond->Wait_queue ) ) { 10ad77: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad7a: 8d 40 18 lea 0x18(%eax),%eax <== NOT EXECUTED 10ad7d: 50 push %eax <== NOT EXECUTED 10ad7e: e8 89 3d 00 00 call 10eb0c <_Thread_queue_First> <== NOT EXECUTED 10ad83: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad86: 85 c0 test %eax,%eax <== NOT EXECUTED 10ad88: 74 1e je 10ada8 <== NOT EXECUTED _Thread_Enable_dispatch(); 10ad8a: e8 75 36 00 00 call 10e404 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ad8f: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ad94: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ad97: c9 leave <== NOT EXECUTED 10ad98: c3 ret <== NOT EXECUTED 10ad99: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { POSIX_Condition_variables_Control *the_cond; Objects_Locations location; the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 10ad9c: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ada1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ada4: c9 leave <== NOT EXECUTED 10ada5: c3 ret <== NOT EXECUTED 10ada6: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( _Thread_queue_First( &the_cond->Wait_queue ) ) { _Thread_Enable_dispatch(); return EBUSY; } _Objects_Close( 10ada8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10adab: 53 push %ebx <== NOT EXECUTED 10adac: 68 00 2c 12 00 push $0x122c00 <== NOT EXECUTED 10adb1: e8 96 29 00 00 call 10d74c <_Objects_Close> <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon * @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 * 10adb6: 58 pop %eax <== NOT EXECUTED 10adb7: 5a pop %edx <== NOT EXECUTED 10adb8: 53 push %ebx <== NOT EXECUTED 10adb9: 68 00 2c 12 00 push $0x122c00 <== NOT EXECUTED 10adbe: e8 c9 2c 00 00 call 10da8c <_Objects_Free> <== NOT EXECUTED &_POSIX_Condition_variables_Information, &the_cond->Object ); _POSIX_Condition_variables_Free( the_cond ); _Thread_Enable_dispatch(); 10adc3: e8 3c 36 00 00 call 10e404 <_Thread_Enable_dispatch> <== NOT EXECUTED 10adc8: 31 c0 xor %eax,%eax <== NOT EXECUTED 10adca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10adcd: eb d2 jmp 10ada1 <== NOT EXECUTED 0010ae24 : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 10ae24: 55 push %ebp <== NOT EXECUTED 10ae25: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae27: 56 push %esi <== NOT EXECUTED 10ae28: 53 push %ebx <== NOT EXECUTED 10ae29: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 10ae2c: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae2e: 0f 84 88 00 00 00 je 10aebc <== NOT EXECUTED 10ae34: 89 c3 mov %eax,%ebx <== NOT EXECUTED /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 10ae36: 83 7b 04 01 cmpl $0x1,0x4(%ebx) <== NOT EXECUTED 10ae3a: 74 06 je 10ae42 <== NOT EXECUTED return EINVAL; if ( !the_attr->is_initialized ) 10ae3c: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10ae3e: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae40: 75 0e jne 10ae50 <== NOT EXECUTED *cond = the_cond->Object.id; _Thread_Enable_dispatch(); return 0; 10ae42: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10ae47: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ae4a: 5b pop %ebx <== NOT EXECUTED 10ae4b: 5e pop %esi <== NOT EXECUTED 10ae4c: c9 leave <== NOT EXECUTED 10ae4d: c3 ret <== NOT EXECUTED 10ae4e: 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 10ae50: a1 18 27 12 00 mov 0x122718,%eax <== NOT EXECUTED 10ae55: 40 inc %eax <== NOT EXECUTED 10ae56: a3 18 27 12 00 mov %eax,0x122718 <== NOT EXECUTED /**@{*/ #ifdef __cplusplus extern "C" { #endif 10ae5b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae5e: 68 00 2c 12 00 push $0x122c00 <== NOT EXECUTED 10ae63: e8 64 28 00 00 call 10d6cc <_Objects_Allocate> <== NOT EXECUTED 10ae68: 89 c6 mov %eax,%esi <== NOT EXECUTED _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 10ae6a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae6d: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae6f: 74 57 je 10aec8 <== NOT EXECUTED _Thread_Enable_dispatch(); return ENOMEM; } the_cond->process_shared = the_attr->process_shared; 10ae71: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10ae74: 89 46 10 mov %eax,0x10(%esi) <== NOT EXECUTED the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 10ae77: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED /* XXX some more initialization might need to go here */ _Thread_queue_Initialize( 10ae7e: 6a 74 push $0x74 <== NOT EXECUTED 10ae80: 68 00 08 00 00 push $0x800 <== NOT EXECUTED 10ae85: 6a 00 push $0x0 <== NOT EXECUTED 10ae87: 8d 46 18 lea 0x18(%esi),%eax <== NOT EXECUTED 10ae8a: 50 push %eax <== NOT EXECUTED 10ae8b: e8 00 3d 00 00 call 10eb90 <_Thread_queue_Initialize> <== NOT EXECUTED 10ae90: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED 10ae93: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10ae96: a1 1c 2c 12 00 mov 0x122c1c,%eax <== NOT EXECUTED 10ae9b: 89 34 90 mov %esi,(%eax,%edx,4) <== NOT EXECUTED 10ae9e: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) <== NOT EXECUTED &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 10aea5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10aea8: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10aeaa: e8 55 35 00 00 call 10e404 <_Thread_Enable_dispatch> <== NOT EXECUTED 10aeaf: 31 c0 xor %eax,%eax <== NOT EXECUTED 10aeb1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10aeb4: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10aeb7: 5b pop %ebx <== NOT EXECUTED 10aeb8: 5e pop %esi <== NOT EXECUTED 10aeb9: c9 leave <== NOT EXECUTED 10aeba: c3 ret <== NOT EXECUTED 10aebb: 90 nop <== NOT EXECUTED ) { POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 10aebc: bb 48 ca 11 00 mov $0x11ca48,%ebx <== NOT EXECUTED 10aec1: e9 70 ff ff ff jmp 10ae36 <== NOT EXECUTED 10aec6: 66 90 xchg %ax,%ax <== NOT EXECUTED _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { _Thread_Enable_dispatch(); 10aec8: e8 37 35 00 00 call 10e404 <_Thread_Enable_dispatch> <== NOT EXECUTED 10aecd: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED 10aed2: e9 70 ff ff ff jmp 10ae47 <== NOT EXECUTED 0010aed8 : */ int pthread_cond_signal( pthread_cond_t *cond ) { 10aed8: 55 push %ebp <== NOT EXECUTED 10aed9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aedb: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _POSIX_Condition_variables_Signal_support( cond, FALSE ); 10aede: 6a 00 push $0x0 <== NOT EXECUTED 10aee0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10aee3: e8 04 00 00 00 call 10aeec <_POSIX_Condition_variables_Signal_support> <== NOT EXECUTED } 10aee8: c9 leave <== NOT EXECUTED 10aee9: c3 ret <== NOT EXECUTED 0010af60 : int pthread_cond_timedwait( pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime ) { 10af60: 55 push %ebp <== NOT EXECUTED 10af61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10af63: 53 push %ebx <== NOT EXECUTED 10af64: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ switch ( _POSIX_Absolute_timeout_to_ticks(abstime, &ticks) ) { 10af67: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10af6a: 50 push %eax <== NOT EXECUTED 10af6b: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10af6e: e8 8d 04 00 00 call 10b400 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 10af73: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af76: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10af79: 77 21 ja 10af9c <== NOT EXECUTED 10af7b: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10af7e: 72 28 jb 10afa8 <== NOT EXECUTED 10af80: b3 01 mov $0x1,%bl <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: already_timedout = FALSE; break; } return _POSIX_Condition_variables_Wait_support( 10af82: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10af85: 50 push %eax <== NOT EXECUTED 10af86: ff 75 f8 pushl -0x8(%ebp) <== NOT EXECUTED 10af89: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10af8c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10af8f: e8 38 00 00 00 call 10afcc <_POSIX_Condition_variables_Wait_support> <== NOT EXECUTED 10af94: 83 c4 10 add $0x10,%esp <== NOT EXECUTED cond, mutex, ticks, already_timedout ); } 10af97: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10af9a: c9 leave <== NOT EXECUTED 10af9b: c3 ret <== NOT EXECUTED * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ switch ( _POSIX_Absolute_timeout_to_ticks(abstime, &ticks) ) { 10af9c: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10af9f: 75 e1 jne 10af82 <== NOT EXECUTED 10afa1: 31 db xor %ebx,%ebx <== NOT EXECUTED 10afa3: eb dd jmp 10af82 <== NOT EXECUTED 10afa5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10afa8: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED cond, mutex, ticks, already_timedout ); } 10afad: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10afb0: c9 leave <== NOT EXECUTED 10afb1: c3 ret <== NOT EXECUTED 0010afb4 : int pthread_cond_wait( pthread_cond_t *cond, pthread_mutex_t *mutex ) { 10afb4: 55 push %ebp <== NOT EXECUTED 10afb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10afb7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED return _POSIX_Condition_variables_Wait_support( 10afba: 6a 00 push $0x0 <== NOT EXECUTED 10afbc: 6a 00 push $0x0 <== NOT EXECUTED 10afbe: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10afc1: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10afc4: e8 03 00 00 00 call 10afcc <_POSIX_Condition_variables_Wait_support> <== NOT EXECUTED cond, mutex, THREAD_QUEUE_WAIT_FOREVER, FALSE ); } 10afc9: c9 leave <== NOT EXECUTED 10afca: c3 ret <== NOT EXECUTED 0010acb8 : */ int pthread_condattr_destroy( pthread_condattr_t *attr ) { 10acb8: 55 push %ebp <== NOT EXECUTED 10acb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10acbb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || attr->is_initialized == FALSE ) 10acbe: 85 c0 test %eax,%eax <== NOT EXECUTED 10acc0: 74 12 je 10acd4 <== NOT EXECUTED 10acc2: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10acc4: 85 d2 test %edx,%edx <== NOT EXECUTED 10acc6: 74 0c je 10acd4 <== NOT EXECUTED return EINVAL; attr->is_initialized = FALSE; 10acc8: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 10acce: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10acd0: c9 leave <== NOT EXECUTED 10acd1: c3 ret <== NOT EXECUTED 10acd2: 66 90 xchg %ax,%ax <== NOT EXECUTED { if ( !attr || attr->is_initialized == FALSE ) return EINVAL; attr->is_initialized = FALSE; return 0; 10acd4: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10acd9: c9 leave <== NOT EXECUTED 10acda: c3 ret <== NOT EXECUTED 0010acdc : int pthread_condattr_getpshared( const pthread_condattr_t *attr, int *pshared ) { 10acdc: 55 push %ebp <== NOT EXECUTED 10acdd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10acdf: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr ) 10ace2: 85 c0 test %eax,%eax <== NOT EXECUTED 10ace4: 74 0e je 10acf4 <== NOT EXECUTED return EINVAL; *pshared = attr->process_shared; 10ace6: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10ace9: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10acec: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10acee: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10acf0: c9 leave <== NOT EXECUTED 10acf1: c3 ret <== NOT EXECUTED 10acf2: 66 90 xchg %ax,%ax <== NOT EXECUTED int pthread_condattr_getpshared( const pthread_condattr_t *attr, int *pshared ) { if ( !attr ) 10acf4: b0 16 mov $0x16,%al <== NOT EXECUTED return EINVAL; *pshared = attr->process_shared; return 0; } 10acf6: c9 leave <== NOT EXECUTED 10acf7: c3 ret <== NOT EXECUTED 0010acf8 : */ int pthread_condattr_init( pthread_condattr_t *attr ) { 10acf8: 55 push %ebp <== NOT EXECUTED 10acf9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10acfb: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED if ( !attr ) 10acfe: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ad00: 74 16 je 10ad18 <== NOT EXECUTED return EINVAL; *attr = _POSIX_Condition_variables_Default_attributes; 10ad02: a1 48 ca 11 00 mov 0x11ca48,%eax <== NOT EXECUTED 10ad07: 8b 15 4c ca 11 00 mov 0x11ca4c,%edx <== NOT EXECUTED 10ad0d: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10ad0f: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED 10ad12: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10ad14: c9 leave <== NOT EXECUTED 10ad15: c3 ret <== NOT EXECUTED 10ad16: 66 90 xchg %ax,%ax <== NOT EXECUTED int pthread_condattr_init( pthread_condattr_t *attr ) { if ( !attr ) 10ad18: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED return EINVAL; *attr = _POSIX_Condition_variables_Default_attributes; return 0; } 10ad1d: c9 leave <== NOT EXECUTED 10ad1e: c3 ret <== NOT EXECUTED 0010ad20 : int pthread_condattr_setpshared( pthread_condattr_t *attr, int pshared ) { 10ad20: 55 push %ebp <== NOT EXECUTED 10ad21: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad23: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr ) 10ad26: 85 c0 test %eax,%eax <== NOT EXECUTED 10ad28: 74 06 je 10ad30 <== NOT EXECUTED return EINVAL; switch ( pshared ) { 10ad2a: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10ad2e: 76 08 jbe 10ad38 <== NOT EXECUTED case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; return 0; 10ad30: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10ad35: c9 leave <== NOT EXECUTED 10ad36: c3 ret <== NOT EXECUTED 10ad37: 90 nop <== NOT EXECUTED return EINVAL; switch ( pshared ) { case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10ad38: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10ad3b: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 10ad3e: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; default: return EINVAL; } } 10ad40: c9 leave <== NOT EXECUTED 10ad41: c3 ret <== NOT EXECUTED 0010aca4 : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 10aca4: 55 push %ebp <== NOT EXECUTED 10aca5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aca7: 57 push %edi <== NOT EXECUTED 10aca8: 56 push %esi <== NOT EXECUTED 10aca9: 53 push %ebx <== NOT EXECUTED 10acaa: 83 ec 5c sub $0x5c,%esp <== NOT EXECUTED 10acad: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED POSIX_API_Control *api; int schedpolicy = SCHED_RR; struct sched_param schedparam; Objects_Name name; if ( !start_routine ) 10acb0: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10acb3: 85 db test %ebx,%ebx <== NOT EXECUTED 10acb5: 0f 84 b9 01 00 00 je 10ae74 <== NOT EXECUTED return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 10acbb: 85 f6 test %esi,%esi <== NOT EXECUTED 10acbd: 0f 84 7d 01 00 00 je 10ae40 <== NOT EXECUTED 10acc3: 89 75 a4 mov %esi,-0x5c(%ebp) <== NOT EXECUTED if ( !the_attr->is_initialized ) 10acc6: 8b 45 a4 mov -0x5c(%ebp),%eax <== NOT EXECUTED 10acc9: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10accb: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10accd: 74 29 je 10acf8 <== NOT EXECUTED * stack space if it is allowed to allocate it itself. * * NOTE: If the user provides the stack we will let it drop below * twice the minimum. */ if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) ) 10accf: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 10acd2: 85 d2 test %edx,%edx <== NOT EXECUTED 10acd4: 74 0b je 10ace1 <== NOT EXECUTED 10acd6: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10acd9: 3b 05 14 ee 11 00 cmp 0x11ee14,%eax <== NOT EXECUTED 10acdf: 72 17 jb 10acf8 <== NOT EXECUTED * inherits scheduling attributes from the creating thread. If it is * PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the * attributes structure. */ switch ( the_attr->inheritsched ) { 10ace1: 8b 75 a4 mov -0x5c(%ebp),%esi <== NOT EXECUTED 10ace4: 8b 46 10 mov 0x10(%esi),%eax <== NOT EXECUTED 10ace7: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10acea: 0f 84 5c 01 00 00 je 10ae4c <== NOT EXECUTED 10acf0: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10acf3: 74 13 je 10ad08 <== NOT EXECUTED 10acf5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ *thread = the_thread->Object.id; _RTEMS_Unlock_allocator(); return 0; 10acf8: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10acfd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ad00: 5b pop %ebx <== NOT EXECUTED 10ad01: 5e pop %esi <== NOT EXECUTED 10ad02: 5f pop %edi <== NOT EXECUTED 10ad03: c9 leave <== NOT EXECUTED 10ad04: c3 ret <== NOT EXECUTED 10ad05: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED schedpolicy = api->schedpolicy; schedparam = api->schedparam; break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 10ad08: 8b 45 a4 mov -0x5c(%ebp),%eax <== NOT EXECUTED 10ad0b: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10ad0e: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED schedparam = the_attr->schedparam; 10ad11: 8d 5d dc lea -0x24(%ebp),%ebx <== NOT EXECUTED 10ad14: 8b 75 a4 mov -0x5c(%ebp),%esi <== NOT EXECUTED 10ad17: 83 c6 18 add $0x18,%esi <== NOT EXECUTED 10ad1a: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10ad1f: 89 df mov %ebx,%edi <== NOT EXECUTED 10ad21: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) 10ad23: 8b 45 a4 mov -0x5c(%ebp),%eax <== NOT EXECUTED 10ad26: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10ad29: 85 c0 test %eax,%eax <== NOT EXECUTED 10ad2b: 0f 85 4f 01 00 00 jne 10ae80 <== NOT EXECUTED /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 10ad31: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 10ad34: 89 55 c0 mov %edx,-0x40(%ebp) <== NOT EXECUTED 10ad37: 89 d0 mov %edx,%eax <== NOT EXECUTED 10ad39: 48 dec %eax <== NOT EXECUTED 10ad3a: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10ad3f: 77 b7 ja 10acf8 <== NOT EXECUTED */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 10ad41: 83 7d cc 01 cmpl $0x1,-0x34(%ebp) <== NOT EXECUTED 10ad45: 0f 84 55 01 00 00 je 10aea0 <== NOT EXECUTED 10ad4b: 0f 8e ef 01 00 00 jle 10af40 <== NOT EXECUTED 10ad51: 83 7d cc 02 cmpl $0x2,-0x34(%ebp) <== NOT EXECUTED 10ad55: 0f 84 31 01 00 00 je 10ae8c <== NOT EXECUTED 10ad5b: 83 7d cc 03 cmpl $0x3,-0x34(%ebp) <== NOT EXECUTED 10ad5f: 75 97 jne 10acf8 <== NOT EXECUTED case SCHED_SPORADIC: budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; budget_callout = _POSIX_Threads_Sporadic_budget_callout; if ( _Timespec_To_ticks( &schedparam.ss_replenish_period ) < 10ad61: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad64: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10ad67: 50 push %eax <== NOT EXECUTED 10ad68: e8 ab 3f 00 00 call 10ed18 <_Timespec_To_ticks> <== NOT EXECUTED 10ad6d: 89 c6 mov %eax,%esi <== NOT EXECUTED 10ad6f: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10ad72: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10ad75: e8 9e 3f 00 00 call 10ed18 <_Timespec_To_ticks> <== NOT EXECUTED 10ad7a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad7d: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10ad7f: 0f 82 73 ff ff ff jb 10acf8 <== NOT EXECUTED _Timespec_To_ticks( &schedparam.ss_initial_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( schedparam.ss_low_priority ) ) 10ad85: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10ad88: 48 dec %eax <== NOT EXECUTED 10ad89: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10ad8e: 0f 87 64 ff ff ff ja 10acf8 <== NOT EXECUTED 10ad94: c7 45 c4 03 00 00 00 movl $0x3,-0x3c(%ebp) <== NOT EXECUTED 10ad9b: c7 45 c8 20 b3 10 00 movl $0x10b320,-0x38(%ebp) <== NOT EXECUTED 10ada2: 66 90 xchg %ax,%ax <== NOT EXECUTED #endif /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 10ada4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ada7: ff 35 74 34 12 00 pushl 0x123474 <== NOT EXECUTED 10adad: e8 82 1b 00 00 call 10c934 <_API_Mutex_Lock> <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 10adb2: c7 04 24 80 36 12 00 movl $0x123680,(%esp) <== NOT EXECUTED 10adb9: e8 e2 24 00 00 call 10d2a0 <_Objects_Allocate> <== NOT EXECUTED 10adbe: 89 45 a8 mov %eax,-0x58(%ebp) <== NOT EXECUTED * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { 10adc1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10adc4: 85 c0 test %eax,%eax <== NOT EXECUTED 10adc6: 0f 84 92 01 00 00 je 10af5e <== NOT EXECUTED /* * Initialize the core thread for this task. */ name.name_p = NULL; /* posix threads don't have a name by default */ status = _Thread_Initialize( 10adcc: 8b 75 a4 mov -0x5c(%ebp),%esi <== NOT EXECUTED 10adcf: 8b 56 08 mov 0x8(%esi),%edx <== NOT EXECUTED 10add2: 50 push %eax <== NOT EXECUTED 10add3: 6a 00 push $0x0 <== NOT EXECUTED 10add5: 6a 00 push $0x0 <== NOT EXECUTED 10add7: ff 75 c8 pushl -0x38(%ebp) <== NOT EXECUTED 10adda: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED 10addd: 6a 01 push $0x1 <== NOT EXECUTED 10addf: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10ade4: 2b 45 c0 sub -0x40(%ebp),%eax <== NOT EXECUTED 10ade7: 50 push %eax <== NOT EXECUTED 10ade8: 6a 01 push $0x1 <== NOT EXECUTED 10adea: a1 14 ee 11 00 mov 0x11ee14,%eax <== NOT EXECUTED 10adef: d1 e0 shl %eax <== NOT EXECUTED 10adf1: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10adf3: 73 02 jae 10adf7 <== NOT EXECUTED 10adf5: 89 d0 mov %edx,%eax <== NOT EXECUTED 10adf7: 50 push %eax <== NOT EXECUTED 10adf8: 8b 7d a4 mov -0x5c(%ebp),%edi <== NOT EXECUTED 10adfb: ff 77 04 pushl 0x4(%edi) <== NOT EXECUTED 10adfe: ff 75 a8 pushl -0x58(%ebp) <== NOT EXECUTED 10ae01: 68 80 36 12 00 push $0x123680 <== NOT EXECUTED 10ae06: e8 9d 32 00 00 call 10e0a8 <_Thread_Initialize> <== NOT EXECUTED budget_callout, 0, /* isr level */ name /* posix threads don't have a name */ ); if ( !status ) { 10ae0b: 83 c4 30 add $0x30,%esp <== NOT EXECUTED 10ae0e: 84 c0 test %al,%al <== NOT EXECUTED 10ae10: 0f 85 9e 00 00 00 jne 10aeb4 <== NOT EXECUTED * 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. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 10ae16: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ae19: ff 75 a8 pushl -0x58(%ebp) <== NOT EXECUTED 10ae1c: 68 80 36 12 00 push $0x123680 <== NOT EXECUTED 10ae21: e8 3a 28 00 00 call 10d660 <_Objects_Free> <== NOT EXECUTED _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 10ae26: 5f pop %edi <== NOT EXECUTED 10ae27: ff 35 74 34 12 00 pushl 0x123474 <== NOT EXECUTED 10ae2d: e8 4a 1b 00 00 call 10c97c <_API_Mutex_Unlock> <== NOT EXECUTED 10ae32: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 10ae37: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae3a: e9 be fe ff ff jmp 10acfd <== NOT EXECUTED 10ae3f: 90 nop <== NOT EXECUTED Objects_Name name; if ( !start_routine ) return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 10ae40: c7 45 a4 a0 c9 11 00 movl $0x11c9a0,-0x5c(%ebp) <== NOT EXECUTED 10ae47: e9 7a fe ff ff jmp 10acc6 <== NOT EXECUTED * attributes structure. */ switch ( the_attr->inheritsched ) { case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10ae4c: a1 7c 34 12 00 mov 0x12347c,%eax <== NOT EXECUTED 10ae51: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax <== NOT EXECUTED schedpolicy = api->schedpolicy; 10ae57: 8b 78 7c mov 0x7c(%eax),%edi <== NOT EXECUTED 10ae5a: 89 7d cc mov %edi,-0x34(%ebp) <== NOT EXECUTED schedparam = api->schedparam; 10ae5d: 8d 5d dc lea -0x24(%ebp),%ebx <== NOT EXECUTED 10ae60: 8d b0 80 00 00 00 lea 0x80(%eax),%esi <== NOT EXECUTED 10ae66: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10ae6b: 89 df mov %ebx,%edi <== NOT EXECUTED 10ae6d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10ae6f: e9 af fe ff ff jmp 10ad23 <== NOT EXECUTED POSIX_API_Control *api; int schedpolicy = SCHED_RR; struct sched_param schedparam; Objects_Name name; if ( !start_routine ) 10ae74: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 10ae79: e9 7f fe ff ff jmp 10acfd <== NOT EXECUTED 10ae7e: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) 10ae80: b8 86 00 00 00 mov $0x86,%eax <== NOT EXECUTED 10ae85: e9 73 fe ff ff jmp 10acfd <== NOT EXECUTED 10ae8a: 66 90 xchg %ax,%ax <== NOT EXECUTED */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 10ae8c: c7 45 c4 02 00 00 00 movl $0x2,-0x3c(%ebp) <== NOT EXECUTED 10ae93: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) <== NOT EXECUTED 10ae9a: e9 05 ff ff ff jmp 10ada4 <== NOT EXECUTED 10ae9f: 90 nop <== NOT EXECUTED 10aea0: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) <== NOT EXECUTED 10aea7: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) <== NOT EXECUTED 10aeae: e9 f1 fe ff ff jmp 10ada4 <== NOT EXECUTED 10aeb3: 90 nop <== NOT EXECUTED /* * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10aeb4: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED 10aeb7: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax <== NOT EXECUTED 10aebd: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED api->Attributes = *the_attr; 10aec0: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 10aec5: 89 c7 mov %eax,%edi <== NOT EXECUTED 10aec7: 8b 75 a4 mov -0x5c(%ebp),%esi <== NOT EXECUTED 10aeca: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED api->detachstate = the_attr->detachstate; 10aecc: 8b 55 a4 mov -0x5c(%ebp),%edx <== NOT EXECUTED 10aecf: 8b 42 34 mov 0x34(%edx),%eax <== NOT EXECUTED 10aed2: 8b 75 d0 mov -0x30(%ebp),%esi <== NOT EXECUTED 10aed5: 89 46 38 mov %eax,0x38(%esi) <== NOT EXECUTED api->schedpolicy = schedpolicy; 10aed8: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED 10aedb: 89 7e 7c mov %edi,0x7c(%esi) <== NOT EXECUTED api->schedparam = schedparam; 10aede: 89 f7 mov %esi,%edi <== NOT EXECUTED 10aee0: 83 ef 80 sub $0xffffff80,%edi <== NOT EXECUTED 10aee3: b1 06 mov $0x6,%cl <== NOT EXECUTED 10aee5: 89 de mov %ebx,%esi <== NOT EXECUTED 10aee7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED * first run. * * NOTE: Since the thread starts with all unblocked, this is necessary. */ the_thread->do_post_task_switch_extension = true; 10aee9: 8b 7d a8 mov -0x58(%ebp),%edi <== NOT EXECUTED 10aeec: c6 47 75 01 movb $0x1,0x75(%edi) <== NOT EXECUTED /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 10aef0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aef3: 6a 00 push $0x0 <== NOT EXECUTED 10aef5: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10aef8: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10aefb: 6a 01 push $0x1 <== NOT EXECUTED 10aefd: 57 push %edi <== NOT EXECUTED 10aefe: e8 fd 3b 00 00 call 10eb00 <_Thread_Start> <== NOT EXECUTED 10af03: 88 c3 mov %al,%bl <== NOT EXECUTED start_routine, arg, 0 /* unused */ ); if ( schedpolicy == SCHED_SPORADIC ) { 10af05: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10af08: 83 7d cc 03 cmpl $0x3,-0x34(%ebp) <== NOT EXECUTED 10af0c: 0f 84 8a 00 00 00 je 10af9c <== NOT EXECUTED * * NOTE: This can only happen if someone slips in and touches the * thread while we are creating it. */ if ( !status ) { 10af12: 84 db test %bl,%bl <== NOT EXECUTED 10af14: 75 63 jne 10af79 <== NOT EXECUTED 10af16: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10af19: ff 75 a8 pushl -0x58(%ebp) <== NOT EXECUTED 10af1c: 68 80 36 12 00 push $0x123680 <== NOT EXECUTED 10af21: e8 3a 27 00 00 call 10d660 <_Objects_Free> <== NOT EXECUTED _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 10af26: 58 pop %eax <== NOT EXECUTED 10af27: ff 35 74 34 12 00 pushl 0x123474 <== NOT EXECUTED 10af2d: e8 4a 1a 00 00 call 10c97c <_API_Mutex_Unlock> <== NOT EXECUTED 10af32: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10af37: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af3a: e9 be fd ff ff jmp 10acfd <== NOT EXECUTED 10af3f: 90 nop <== NOT EXECUTED */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 10af40: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10af43: 85 c0 test %eax,%eax <== NOT EXECUTED 10af45: 0f 85 ad fd ff ff jne 10acf8 <== NOT EXECUTED 10af4b: c7 45 c4 01 00 00 00 movl $0x1,-0x3c(%ebp) <== NOT EXECUTED 10af52: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) <== NOT EXECUTED 10af59: e9 46 fe ff ff jmp 10ada4 <== NOT EXECUTED */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { _RTEMS_Unlock_allocator(); 10af5e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af61: ff 35 74 34 12 00 pushl 0x123474 <== NOT EXECUTED 10af67: e8 10 1a 00 00 call 10c97c <_API_Mutex_Unlock> <== NOT EXECUTED 10af6c: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 10af71: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af74: e9 84 fd ff ff jmp 10acfd <== NOT EXECUTED /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 10af79: 8b 75 a8 mov -0x58(%ebp),%esi <== NOT EXECUTED 10af7c: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10af7f: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10af82: 89 07 mov %eax,(%edi) <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10af84: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af87: ff 35 74 34 12 00 pushl 0x123474 <== NOT EXECUTED 10af8d: e8 ea 19 00 00 call 10c97c <_API_Mutex_Unlock> <== NOT EXECUTED 10af92: 31 c0 xor %eax,%eax <== NOT EXECUTED 10af94: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af97: e9 61 fd ff ff jmp 10acfd <== NOT EXECUTED arg, 0 /* unused */ ); if ( schedpolicy == SCHED_SPORADIC ) { _Watchdog_Insert_ticks( 10af9c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af9f: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 10afa2: 05 88 00 00 00 add $0x88,%eax <== NOT EXECUTED 10afa7: 50 push %eax <== NOT EXECUTED 10afa8: e8 6b 3d 00 00 call 10ed18 <_Timespec_To_ticks> <== 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, 10afad: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 10afb0: 89 82 a8 00 00 00 mov %eax,0xa8(%edx) <== NOT EXECUTED void *starting_address, size_t *size 10afb6: 59 pop %ecx <== NOT EXECUTED 10afb7: 5e pop %esi <== NOT EXECUTED 10afb8: 89 d0 mov %edx,%eax <== NOT EXECUTED 10afba: 05 9c 00 00 00 add $0x9c,%eax <== NOT EXECUTED 10afbf: 50 push %eax <== NOT EXECUTED 10afc0: 68 9c 34 12 00 push $0x12349c <== NOT EXECUTED 10afc5: e8 d6 40 00 00 call 10f0a0 <_Watchdog_Insert> <== NOT EXECUTED 10afca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10afcd: e9 40 ff ff ff jmp 10af12 <== NOT EXECUTED 0010a3dc : #include int pthread_detach( pthread_t thread ) { 10a3dc: 55 push %ebp <== NOT EXECUTED 10a3dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a3df: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10a3e2: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10a3e5: 50 push %eax <== NOT EXECUTED 10a3e6: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a3e9: 68 20 24 12 00 push $0x122420 <== NOT EXECUTED 10a3ee: e8 dd 24 00 00 call 10c8d0 <_Objects_Get> <== NOT EXECUTED register Thread_Control *the_thread; POSIX_API_Control *api; Objects_Locations location; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 10a3f3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a3f6: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10a3f9: 85 d2 test %edx,%edx <== NOT EXECUTED 10a3fb: 75 17 jne 10a414 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->detachstate = PTHREAD_CREATE_DETACHED; 10a3fd: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax <== NOT EXECUTED 10a403: c7 40 38 00 00 00 00 movl $0x0,0x38(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a40a: e8 05 2d 00 00 call 10d114 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a40f: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10a411: c9 leave <== NOT EXECUTED 10a412: c3 ret <== NOT EXECUTED 10a413: 90 nop <== NOT EXECUTED register Thread_Control *the_thread; POSIX_API_Control *api; Objects_Locations location; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 10a414: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10a419: c9 leave <== NOT EXECUTED 10a41a: c3 ret <== NOT EXECUTED 0010afd4 : int pthread_equal( pthread_t t1, pthread_t t2 ) { 10afd4: 55 push %ebp <== NOT EXECUTED 10afd5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10afd7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10afda: 39 45 08 cmp %eax,0x8(%ebp) <== NOT EXECUTED 10afdd: 0f 94 c0 sete %al <== NOT EXECUTED 10afe0: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED break; } return status; #endif } 10afe3: c9 leave <== NOT EXECUTED 10afe4: c3 ret <== NOT EXECUTED 00110770 : } void pthread_exit( void *value_ptr ) { 110770: 55 push %ebp <== NOT EXECUTED 110771: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110773: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED _POSIX_Thread_Exit( _Thread_Executing, value_ptr ); 110776: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 110779: ff 35 7c f8 11 00 pushl 0x11f87c <== NOT EXECUTED 11077f: e8 88 ff ff ff call 11070c <_POSIX_Thread_Exit> <== NOT EXECUTED 110784: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 110787: c9 leave <== NOT EXECUTED 110788: c3 ret <== NOT EXECUTED 0010a3c0 : int pthread_getcpuclockid( pthread_t pid, clockid_t *clock_id ) { 10a3c0: 55 push %ebp <== NOT EXECUTED 10a3c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a3c3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a3c6: e8 b5 76 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a3cb: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a3d1: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a3d6: c9 leave <== NOT EXECUTED 10a3d7: c3 ret <== NOT EXECUTED 0010c518 : int pthread_getschedparam( pthread_t thread, int *policy, struct sched_param *param ) { 10c518: 55 push %ebp <== NOT EXECUTED 10c519: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c51b: 57 push %edi <== NOT EXECUTED 10c51c: 56 push %esi <== NOT EXECUTED 10c51d: 53 push %ebx <== NOT EXECUTED 10c51e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10c521: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Objects_Locations location; POSIX_API_Control *api; register Thread_Control *the_thread; if ( !policy || !param ) 10c524: 85 f6 test %esi,%esi <== NOT EXECUTED 10c526: 74 6c je 10c594 <== NOT EXECUTED 10c528: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10c52b: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10c52d: 74 65 je 10c594 <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10c52f: 52 push %edx <== NOT EXECUTED 10c530: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10c533: 50 push %eax <== NOT EXECUTED 10c534: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c537: 68 60 54 12 00 push $0x125460 <== NOT EXECUTED 10c53c: e8 cf 25 00 00 call 10eb10 <_Objects_Get> <== NOT EXECUTED 10c541: 89 c3 mov %eax,%ebx <== NOT EXECUTED return EINVAL; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 10c543: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c546: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10c549: 85 c0 test %eax,%eax <== NOT EXECUTED 10c54b: 75 37 jne 10c584 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10c54d: 8b 93 f8 00 00 00 mov 0xf8(%ebx),%edx <== NOT EXECUTED if ( policy ) *policy = api->schedpolicy; 10c553: 8b 42 7c mov 0x7c(%edx),%eax <== NOT EXECUTED 10c556: 89 06 mov %eax,(%esi) <== NOT EXECUTED if ( param ) { *param = api->schedparam; 10c558: 8d b2 80 00 00 00 lea 0x80(%edx),%esi <== NOT EXECUTED 10c55e: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10c563: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10c566: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED param->sched_priority = 10c568: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10c56d: 2b 43 14 sub 0x14(%ebx),%eax <== NOT EXECUTED 10c570: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10c573: 89 02 mov %eax,(%edx) <== NOT EXECUTED _POSIX_Priority_From_core( the_thread->current_priority ); } _Thread_Enable_dispatch(); 10c575: e8 da 2d 00 00 call 10f354 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c57a: 31 c0 xor %eax,%eax <== NOT EXECUTED break; } return ESRCH; } 10c57c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c57f: 5b pop %ebx <== NOT EXECUTED 10c580: 5e pop %esi <== NOT EXECUTED 10c581: 5f pop %edi <== NOT EXECUTED 10c582: c9 leave <== NOT EXECUTED 10c583: c3 ret <== NOT EXECUTED if ( !policy || !param ) return EINVAL; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 10c584: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED break; } return ESRCH; } 10c589: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c58c: 5b pop %ebx <== NOT EXECUTED 10c58d: 5e pop %esi <== NOT EXECUTED 10c58e: 5f pop %edi <== NOT EXECUTED 10c58f: c9 leave <== NOT EXECUTED 10c590: c3 ret <== NOT EXECUTED 10c591: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED *param = api->schedparam; param->sched_priority = _POSIX_Priority_From_core( the_thread->current_priority ); } _Thread_Enable_dispatch(); return 0; 10c594: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED break; } return ESRCH; } 10c599: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c59c: 5b pop %ebx <== NOT EXECUTED 10c59d: 5e pop %esi <== NOT EXECUTED 10c59e: 5f pop %edi <== NOT EXECUTED 10c59f: c9 leave <== NOT EXECUTED 10c5a0: c3 ret <== NOT EXECUTED 0010a26c : */ void *pthread_getspecific( pthread_key_t key ) { 10a26c: 55 push %ebp <== NOT EXECUTED 10a26d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a26f: 53 push %ebx <== NOT EXECUTED 10a270: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10a273: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a276: 50 push %eax <== NOT EXECUTED 10a277: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a27a: 68 40 27 12 00 push $0x122740 <== NOT EXECUTED 10a27f: e8 ec 27 00 00 call 10ca70 <_Objects_Get> <== NOT EXECUTED 10a284: 89 c1 mov %eax,%ecx <== NOT EXECUTED uint32_t index; Objects_Locations location; void *key_data; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 10a286: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a289: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10a28c: 85 c0 test %eax,%eax <== NOT EXECUTED 10a28e: 75 2c jne 10a2bc <== NOT EXECUTED case OBJECTS_LOCAL: api = _Objects_Get_API( _Thread_Executing->Object.id ); 10a290: a1 5c 23 12 00 mov 0x12235c,%eax <== NOT EXECUTED 10a295: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED index = _Objects_Get_index( _Thread_Executing->Object.id ); key_data = (void *) the_key->Values[ api ][ index ]; 10a298: 89 d0 mov %edx,%eax <== NOT EXECUTED 10a29a: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10a29d: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 10a2a0: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10a2a6: 8b 44 81 18 mov 0x18(%ecx,%eax,4),%eax <== NOT EXECUTED 10a2aa: 8b 1c 90 mov (%eax,%edx,4),%ebx <== NOT EXECUTED _Thread_Enable_dispatch(); 10a2ad: e8 02 30 00 00 call 10d2b4 <_Thread_Enable_dispatch> <== NOT EXECUTED case OBJECTS_ERROR: break; } return NULL; } 10a2b2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a2b4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a2b7: c9 leave <== NOT EXECUTED 10a2b8: c3 ret <== NOT EXECUTED 10a2b9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED uint32_t index; Objects_Locations location; void *key_data; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 10a2bc: 31 db xor %ebx,%ebx <== NOT EXECUTED case OBJECTS_ERROR: break; } return NULL; } 10a2be: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a2c0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a2c3: c9 leave <== NOT EXECUTED 10a2c4: c3 ret <== NOT EXECUTED 0010e52c : int pthread_join( pthread_t thread, void **value_ptr ) { 10e52c: 55 push %ebp <== NOT EXECUTED 10e52d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e52f: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10e532: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10e535: 50 push %eax <== NOT EXECUTED 10e536: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10e539: 68 60 93 12 00 push $0x129360 <== NOT EXECUTED 10e53e: e8 a5 25 00 00 call 110ae8 <_Objects_Get> <== NOT EXECUTED POSIX_API_Control *api; Objects_Locations location; void *return_pointer; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 10e543: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e546: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10e549: 85 d2 test %edx,%edx <== NOT EXECUTED 10e54b: 74 07 je 10e554 <== NOT EXECUTED 10e54d: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10e552: c9 leave <== NOT EXECUTED 10e553: c3 ret <== NOT EXECUTED the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10e554: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx <== NOT EXECUTED if ( api->detachstate == PTHREAD_CREATE_DETACHED ) { 10e55a: 8b 4a 38 mov 0x38(%edx),%ecx <== NOT EXECUTED 10e55d: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10e55f: 74 43 je 10e5a4 <== NOT EXECUTED 10e561: 8b 0d 5c 91 12 00 mov 0x12915c,%ecx <== NOT EXECUTED _Thread_Enable_dispatch(); return EINVAL; } if ( _Thread_Is_executing( the_thread ) ) { 10e567: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10e569: 74 45 je 10e5b0 <== NOT EXECUTED /* * Put ourself on the threads join list */ _Thread_Executing->Wait.return_argument = &return_pointer; 10e56b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10e56e: 89 41 28 mov %eax,0x28(%ecx) <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10e571: c7 42 6c 01 00 00 00 movl $0x1,0x6c(%edx) <== NOT EXECUTED _Thread_queue_Enter_critical_section( &api->Join_List ); _Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT ); 10e578: 51 push %ecx <== NOT EXECUTED 10e579: 68 3c 1b 11 00 push $0x111b3c <== NOT EXECUTED 10e57e: 6a 00 push $0x0 <== NOT EXECUTED 10e580: 8d 42 3c lea 0x3c(%edx),%eax <== NOT EXECUTED 10e583: 50 push %eax <== NOT EXECUTED 10e584: e8 63 32 00 00 call 1117ec <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 10e589: e8 9e 2d 00 00 call 11132c <_Thread_Enable_dispatch> <== NOT EXECUTED if ( value_ptr ) 10e58e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e591: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e594: 85 c0 test %eax,%eax <== NOT EXECUTED 10e596: 74 08 je 10e5a0 <== NOT EXECUTED *value_ptr = return_pointer; 10e598: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10e59b: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10e59e: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10e5a0: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10e5a2: c9 leave <== NOT EXECUTED 10e5a3: c3 ret <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( api->detachstate == PTHREAD_CREATE_DETACHED ) { _Thread_Enable_dispatch(); 10e5a4: e8 83 2d 00 00 call 11132c <_Thread_Enable_dispatch> <== NOT EXECUTED 10e5a9: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10e5ae: c9 leave <== NOT EXECUTED 10e5af: c3 ret <== NOT EXECUTED _Thread_Enable_dispatch(); return EINVAL; } if ( _Thread_Is_executing( the_thread ) ) { _Thread_Enable_dispatch(); 10e5b0: e8 77 2d 00 00 call 11132c <_Thread_Enable_dispatch> <== NOT EXECUTED 10e5b5: b8 2d 00 00 00 mov $0x2d,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10e5ba: c9 leave <== NOT EXECUTED 10e5bb: c3 ret <== NOT EXECUTED 0010a0ac : int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) { 10a0ac: 55 push %ebp <== NOT EXECUTED 10a0ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a0af: 57 push %edi <== NOT EXECUTED 10a0b0: 56 push %esi <== NOT EXECUTED 10a0b1: 53 push %ebx <== NOT EXECUTED 10a0b2: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10a0b5: a1 98 22 12 00 mov 0x122298,%eax <== NOT EXECUTED 10a0ba: 40 inc %eax <== NOT EXECUTED 10a0bb: a3 98 22 12 00 mov %eax,0x122298 <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 10a0c0: 68 40 27 12 00 push $0x122740 <== NOT EXECUTED 10a0c5: e8 b2 24 00 00 call 10c57c <_Objects_Allocate> <== NOT EXECUTED 10a0ca: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED _Thread_Disable_dispatch(); the_key = _POSIX_Keys_Allocate(); if ( !the_key ) { 10a0cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a0d0: 85 c0 test %eax,%eax <== NOT EXECUTED 10a0d2: 0f 84 8c 00 00 00 je 10a164 <== NOT EXECUTED _Thread_Enable_dispatch(); return EAGAIN; } the_key->destructor = destructor; 10a0d8: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10a0db: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10a0de: 89 50 14 mov %edx,0x14(%eax) <== NOT EXECUTED 10a0e1: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { if ( _Objects_Information_table[ the_api ] ) { 10a0e6: 8b 04 9d 6c 22 12 00 mov 0x12226c(,%ebx,4),%eax <== NOT EXECUTED 10a0ed: 85 c0 test %eax,%eax <== NOT EXECUTED 10a0ef: 74 63 je 10a154 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY ); #endif bytes_to_allocate = sizeof( void * ) * 10a0f1: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10a0f4: 0f b7 40 10 movzwl 0x10(%eax),%eax <== NOT EXECUTED 10a0f8: 8d 34 85 04 00 00 00 lea 0x4(,%eax,4),%esi <== NOT EXECUTED (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); 10a0ff: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a102: 56 push %esi <== NOT EXECUTED 10a103: e8 fc 43 00 00 call 10e504 <_Workspace_Allocate> <== NOT EXECUTED 10a108: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( !table ) { 10a10a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a10d: 85 c0 test %eax,%eax <== NOT EXECUTED 10a10f: 74 67 je 10a178 <== NOT EXECUTED _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); return ENOMEM; } the_key->Values[ the_api ] = table; 10a111: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10a114: 89 44 9a 18 mov %eax,0x18(%edx,%ebx,4) <== NOT EXECUTED memset( table, '\0', bytes_to_allocate ); 10a118: 89 f1 mov %esi,%ecx <== NOT EXECUTED 10a11a: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a11c: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED * for. [NOTE: Currently RTEMS Classic API tasks are always enabled.] */ for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 10a11e: 43 inc %ebx <== NOT EXECUTED * APIs are optional. Thus there may be no ITRON tasks to have keys * for. [NOTE: Currently RTEMS Classic API tasks are always enabled.] */ for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; 10a11f: 83 fb 05 cmp $0x5,%ebx <== NOT EXECUTED 10a122: 75 c2 jne 10a0e6 <== NOT EXECUTED } } the_key->is_active = TRUE; 10a124: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 10a127: c6 43 10 01 movb $0x1,0x10(%ebx) <== NOT EXECUTED 10a12b: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10a12e: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10a131: a1 5c 27 12 00 mov 0x12275c,%eax <== NOT EXECUTED 10a136: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10a139: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED _Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 ); *key = the_key->Object.id; 10a140: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a143: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a145: e8 6a 31 00 00 call 10d2b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a14a: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10a14c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a14f: 5b pop %ebx <== NOT EXECUTED 10a150: 5e pop %esi <== NOT EXECUTED 10a151: 5f pop %edi <== NOT EXECUTED 10a152: c9 leave <== NOT EXECUTED 10a153: c3 ret <== NOT EXECUTED } the_key->Values[ the_api ] = table; memset( table, '\0', bytes_to_allocate ); } else { the_key->Values[ the_api ] = NULL; 10a154: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10a157: c7 44 9a 18 00 00 00 movl $0x0,0x18(%edx,%ebx,4) <== NOT EXECUTED 10a15e: 00 <== NOT EXECUTED 10a15f: eb bd jmp 10a11e <== NOT EXECUTED 10a161: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Disable_dispatch(); the_key = _POSIX_Keys_Allocate(); if ( !the_key ) { _Thread_Enable_dispatch(); 10a164: e8 4b 31 00 00 call 10d2b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a169: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED *key = the_key->Object.id; _Thread_Enable_dispatch(); return 0; } 10a16e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a171: 5b pop %ebx <== NOT EXECUTED 10a172: 5e pop %esi <== NOT EXECUTED 10a173: 5f pop %edi <== NOT EXECUTED 10a174: c9 leave <== NOT EXECUTED 10a175: c3 ret <== NOT EXECUTED 10a176: 66 90 xchg %ax,%ax <== NOT EXECUTED bytes_to_allocate = sizeof( void * ) * (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); if ( !table ) { for ( --the_api; the_api >= 1; 10a178: 89 de mov %ebx,%esi <== NOT EXECUTED 10a17a: 4e dec %esi <== NOT EXECUTED 10a17b: 74 1a je 10a197 <== NOT EXECUTED 10a17d: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10a180: 8d 5c 98 14 lea 0x14(%eax,%ebx,4),%ebx <== NOT EXECUTED the_api-- ) _Workspace_Free( the_key->Values[ the_api ] ); 10a184: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a187: ff 33 pushl (%ebx) <== NOT EXECUTED 10a189: e8 5e 43 00 00 call 10e4ec <_Workspace_Free> <== NOT EXECUTED (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); if ( !table ) { for ( --the_api; the_api >= 1; the_api-- ) 10a18e: 83 eb 04 sub $0x4,%ebx <== NOT EXECUTED bytes_to_allocate = sizeof( void * ) * (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); if ( !table ) { for ( --the_api; the_api >= 1; 10a191: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a194: 4e dec %esi <== NOT EXECUTED 10a195: 75 ed jne 10a184 <== NOT EXECUTED * 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. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 10a197: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a19a: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10a19d: 68 40 27 12 00 push $0x122740 <== NOT EXECUTED 10a1a2: e8 95 27 00 00 call 10c93c <_Objects_Free> <== NOT EXECUTED the_api-- ) _Workspace_Free( the_key->Values[ the_api ] ); _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); 10a1a7: e8 08 31 00 00 call 10d2b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a1ac: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED 10a1b1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a1b4: eb 96 jmp 10a14c <== NOT EXECUTED 0010a1b8 : */ int pthread_key_delete( pthread_key_t key ) { 10a1b8: 55 push %ebp <== NOT EXECUTED 10a1b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a1bb: 53 push %ebx <== NOT EXECUTED 10a1bc: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10a1bf: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a1c2: 50 push %eax <== NOT EXECUTED 10a1c3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a1c6: 68 40 27 12 00 push $0x122740 <== NOT EXECUTED 10a1cb: e8 a0 28 00 00 call 10ca70 <_Objects_Get> <== NOT EXECUTED 10a1d0: 89 c3 mov %eax,%ebx <== NOT EXECUTED register POSIX_Keys_Control *the_key; Objects_Locations location; uint32_t the_api; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 10a1d2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a1d5: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10a1d8: 85 c0 test %eax,%eax <== NOT EXECUTED 10a1da: 0f 85 80 00 00 00 jne 10a260 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_POSIX_Keys_Information, &the_key->Object ); 10a1e0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a1e3: 53 push %ebx <== NOT EXECUTED 10a1e4: 68 40 27 12 00 push $0x122740 <== NOT EXECUTED 10a1e9: e8 0e 24 00 00 call 10c5fc <_Objects_Close> <== NOT EXECUTED the_key->is_active = FALSE; 10a1ee: c6 43 10 00 movb $0x0,0x10(%ebx) <== NOT EXECUTED for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 10a1f2: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10a1f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a1f8: 85 c0 test %eax,%eax <== NOT EXECUTED 10a1fa: 74 0c je 10a208 <== NOT EXECUTED _Workspace_Free( the_key->Values[ the_api ] ); 10a1fc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a1ff: 50 push %eax <== NOT EXECUTED 10a200: e8 e7 42 00 00 call 10e4ec <_Workspace_Free> <== NOT EXECUTED 10a205: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 10a208: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 10a20b: 85 c0 test %eax,%eax <== NOT EXECUTED 10a20d: 74 0c je 10a21b <== NOT EXECUTED _Workspace_Free( the_key->Values[ the_api ] ); 10a20f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a212: 50 push %eax <== NOT EXECUTED 10a213: e8 d4 42 00 00 call 10e4ec <_Workspace_Free> <== NOT EXECUTED 10a218: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 10a21b: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 10a21e: 85 c0 test %eax,%eax <== NOT EXECUTED 10a220: 74 0c je 10a22e <== NOT EXECUTED _Workspace_Free( the_key->Values[ the_api ] ); 10a222: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a225: 50 push %eax <== NOT EXECUTED 10a226: e8 c1 42 00 00 call 10e4ec <_Workspace_Free> <== NOT EXECUTED 10a22b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 10a22e: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 10a231: 85 c0 test %eax,%eax <== NOT EXECUTED 10a233: 74 0c je 10a241 <== NOT EXECUTED _Workspace_Free( the_key->Values[ the_api ] ); 10a235: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a238: 50 push %eax <== NOT EXECUTED 10a239: e8 ae 42 00 00 call 10e4ec <_Workspace_Free> <== NOT EXECUTED 10a23e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * 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. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 10a241: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a244: 53 push %ebx <== NOT EXECUTED 10a245: 68 40 27 12 00 push $0x122740 <== NOT EXECUTED 10a24a: e8 ed 26 00 00 call 10c93c <_Objects_Free> <== NOT EXECUTED * NOTE: The destructor is not called and it is the responsibility * of the application to free the memory. */ _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); 10a24f: e8 60 30 00 00 call 10d2b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a254: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a256: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a259: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a25c: c9 leave <== NOT EXECUTED 10a25d: c3 ret <== NOT EXECUTED 10a25e: 66 90 xchg %ax,%ax <== NOT EXECUTED register POSIX_Keys_Control *the_key; Objects_Locations location; uint32_t the_api; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 10a260: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a265: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a268: c9 leave <== NOT EXECUTED 10a269: c3 ret <== NOT EXECUTED 00121f88 : int pthread_kill( pthread_t thread, int sig ) { 121f88: 55 push %ebp <== NOT EXECUTED 121f89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121f8b: 57 push %edi <== NOT EXECUTED 121f8c: 56 push %esi <== NOT EXECUTED 121f8d: 53 push %ebx <== NOT EXECUTED 121f8e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 121f91: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED POSIX_API_Control *api; Thread_Control *the_thread; Objects_Locations location; if ( !sig ) 121f94: 85 f6 test %esi,%esi <== NOT EXECUTED 121f96: 0f 84 8c 00 00 00 je 122028 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 121f9c: 8d 7e ff lea -0x1(%esi),%edi <== NOT EXECUTED 121f9f: 83 ff 1f cmp $0x1f,%edi <== NOT EXECUTED 121fa2: 0f 87 80 00 00 00 ja 122028 <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 121fa8: 51 push %ecx <== NOT EXECUTED 121fa9: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 121fac: 50 push %eax <== NOT EXECUTED 121fad: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 121fb0: 68 c0 df 12 00 push $0x12dfc0 <== NOT EXECUTED 121fb5: e8 5a e9 fe ff call 110914 <_Objects_Get> <== NOT EXECUTED 121fba: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 121fbc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121fbf: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 121fc2: 85 d2 test %edx,%edx <== NOT EXECUTED 121fc4: 75 76 jne 12203c <== NOT EXECUTED case OBJECTS_LOCAL: /* * If sig == 0 then just validate arguments */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 121fc6: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx <== NOT EXECUTED if ( sig ) { if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 121fcc: 8d 04 76 lea (%esi,%esi,2),%eax <== NOT EXECUTED 121fcf: 83 3c 85 88 e3 12 00 cmpl $0x1,0x12e388(,%eax,4) <== NOT EXECUTED 121fd6: 01 <== NOT EXECUTED 121fd7: 74 31 je 12200a <== NOT EXECUTED return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 121fd9: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 121fde: 89 f9 mov %edi,%ecx <== NOT EXECUTED 121fe0: d3 e0 shl %cl,%eax <== NOT EXECUTED 121fe2: 09 82 c8 00 00 00 or %eax,0xc8(%edx) <== NOT EXECUTED (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 121fe8: 50 push %eax <== NOT EXECUTED 121fe9: 6a 00 push $0x0 <== NOT EXECUTED 121feb: 56 push %esi <== NOT EXECUTED 121fec: 53 push %ebx <== NOT EXECUTED 121fed: e8 7a fe ff ff call 121e6c <_POSIX_signals_Unblock_thread> <== NOT EXECUTED the_thread->do_post_task_switch_extension = true; 121ff2: c6 43 75 01 movb $0x1,0x75(%ebx) <== NOT EXECUTED if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 121ff6: a1 58 dd 12 00 mov 0x12dd58,%eax <== NOT EXECUTED 121ffb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121ffe: 85 c0 test %eax,%eax <== NOT EXECUTED 122000: 74 08 je 12200a <== NOT EXECUTED 122002: 3b 1d 7c dd 12 00 cmp 0x12dd7c,%ebx <== NOT EXECUTED 122008: 74 12 je 12201c <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; } _Thread_Enable_dispatch(); 12200a: e8 49 f1 fe ff call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED 12200f: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( ESRCH ); } 122011: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 122014: 5b pop %ebx <== NOT EXECUTED 122015: 5e pop %esi <== NOT EXECUTED 122016: 5f pop %edi <== NOT EXECUTED 122017: c9 leave <== NOT EXECUTED 122018: c3 ret <== NOT EXECUTED 122019: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); the_thread->do_post_task_switch_extension = true; if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _ISR_Signals_to_thread_executing = TRUE; 12201c: c6 05 28 de 12 00 01 movb $0x1,0x12de28 <== NOT EXECUTED 122023: eb e5 jmp 12200a <== NOT EXECUTED 122025: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !sig ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) rtems_set_errno_and_return_minus_one( EINVAL ); 122028: e8 4f 76 ff ff call 11967c <__errno> <== NOT EXECUTED 12202d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 122033: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 122038: eb d7 jmp 122011 <== NOT EXECUTED 12203a: 66 90 xchg %ax,%ax <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( ESRCH ); 12203c: e8 3b 76 ff ff call 11967c <__errno> <== NOT EXECUTED 122041: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED 122047: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12204c: eb c3 jmp 122011 <== NOT EXECUTED 0010bc78 : */ int pthread_mutex_destroy( pthread_mutex_t *mutex ) { 10bc78: 55 push %ebp <== NOT EXECUTED 10bc79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc7b: 53 push %ebx <== NOT EXECUTED 10bc7c: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; the_mutex = _POSIX_Mutex_Get( mutex, &location ); 10bc7f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10bc82: 50 push %eax <== NOT EXECUTED 10bc83: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bc86: e8 c5 00 00 00 call 10bd50 <_POSIX_Mutex_Get> <== NOT EXECUTED 10bc8b: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch ( location ) { 10bc8d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bc90: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10bc93: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc95: 74 0d je 10bca4 <== NOT EXECUTED 10bc97: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10bc9c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bc9f: c9 leave <== NOT EXECUTED 10bca0: c3 ret <== NOT EXECUTED 10bca1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * XXX: There is an error for the mutex being locked * or being in use by a condition variable. */ if ( _CORE_mutex_Is_locked( &the_mutex->Mutex ) ) { 10bca4: 8b 4b 64 mov 0x64(%ebx),%ecx <== NOT EXECUTED 10bca7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bca9: 75 11 jne 10bcbc <== NOT EXECUTED _Thread_Enable_dispatch(); 10bcab: e8 a4 36 00 00 call 10f354 <_Thread_Enable_dispatch> <== NOT EXECUTED 10bcb0: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10bcb5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bcb8: c9 leave <== NOT EXECUTED 10bcb9: c3 ret <== NOT EXECUTED 10bcba: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( _CORE_mutex_Is_locked( &the_mutex->Mutex ) ) { _Thread_Enable_dispatch(); return EBUSY; } _Objects_Close( &_POSIX_Mutex_Information, &the_mutex->Object ); 10bcbc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bcbf: 53 push %ebx <== NOT EXECUTED 10bcc0: 68 a0 55 12 00 push $0x1255a0 <== NOT EXECUTED 10bcc5: e8 d2 29 00 00 call 10e69c <_Objects_Close> <== NOT EXECUTED _CORE_mutex_Flush( &the_mutex->Mutex, NULL, EINVAL ); 10bcca: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10bccd: 6a 16 push $0x16 <== NOT EXECUTED 10bccf: 6a 00 push $0x0 <== NOT EXECUTED 10bcd1: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 10bcd4: 50 push %eax <== NOT EXECUTED 10bcd5: e8 1a 22 00 00 call 10def4 <_CORE_mutex_Flush> <== NOT EXECUTED * 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. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 10bcda: 58 pop %eax <== NOT EXECUTED 10bcdb: 5a pop %edx <== NOT EXECUTED 10bcdc: 53 push %ebx <== NOT EXECUTED 10bcdd: 68 a0 55 12 00 push $0x1255a0 <== NOT EXECUTED 10bce2: e8 f5 2c 00 00 call 10e9dc <_Objects_Free> <== NOT EXECUTED _POSIX_Mutex_Free( the_mutex ); _Thread_Enable_dispatch(); 10bce7: e8 68 36 00 00 call 10f354 <_Thread_Enable_dispatch> <== NOT EXECUTED 10bcec: 31 c0 xor %eax,%eax <== NOT EXECUTED 10bcee: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10bcf1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bcf4: c9 leave <== NOT EXECUTED 10bcf5: c3 ret <== NOT EXECUTED 0010bda4 : int pthread_mutex_getprioceiling( pthread_mutex_t *mutex, int *prioceiling ) { 10bda4: 55 push %ebp <== NOT EXECUTED 10bda5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bda7: 53 push %ebx <== NOT EXECUTED 10bda8: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10bdab: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; if ( !prioceiling ) 10bdae: 85 db test %ebx,%ebx <== NOT EXECUTED 10bdb0: 74 1b je 10bdcd <== NOT EXECUTED return EINVAL; the_mutex = _POSIX_Mutex_Get( mutex, &location ); 10bdb2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bdb5: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10bdb8: 50 push %eax <== NOT EXECUTED 10bdb9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bdbc: e8 8f ff ff ff call 10bd50 <_POSIX_Mutex_Get> <== NOT EXECUTED 10bdc1: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 10bdc3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bdc6: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10bdc9: 85 c0 test %eax,%eax <== NOT EXECUTED 10bdcb: 74 0b je 10bdd8 <== NOT EXECUTED case OBJECTS_LOCAL: *prioceiling = _POSIX_Priority_From_core( the_mutex->Mutex.Attributes.priority_ceiling ); _Thread_Enable_dispatch(); return 0; 10bdcd: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10bdd2: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bdd5: c9 leave <== NOT EXECUTED 10bdd6: c3 ret <== NOT EXECUTED 10bdd7: 90 nop <== NOT EXECUTED the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { case OBJECTS_LOCAL: *prioceiling = _POSIX_Priority_From_core( 10bdd8: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10bddd: 2b 42 60 sub 0x60(%edx),%eax <== NOT EXECUTED 10bde0: 89 03 mov %eax,(%ebx) <== NOT EXECUTED the_mutex->Mutex.Attributes.priority_ceiling ); _Thread_Enable_dispatch(); 10bde2: e8 6d 35 00 00 call 10f354 <_Thread_Enable_dispatch> <== NOT EXECUTED 10bde7: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10bde9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bdec: c9 leave <== NOT EXECUTED 10bded: c3 ret <== NOT EXECUTED 0010bdf0 : int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *attr ) { 10bdf0: 55 push %ebp <== NOT EXECUTED 10bdf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bdf3: 57 push %edi <== NOT EXECUTED 10bdf4: 56 push %esi <== NOT EXECUTED 10bdf5: 53 push %ebx <== NOT EXECUTED 10bdf6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bdf9: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED #if 0 register POSIX_Mutex_Control *mutex_in_use; Objects_Locations location; #endif if ( attr ) the_attr = attr; 10bdfc: 85 c0 test %eax,%eax <== NOT EXECUTED 10bdfe: 0f 84 e0 00 00 00 je 10bee4 <== NOT EXECUTED 10be04: 89 c3 mov %eax,%ebx <== NOT EXECUTED else the_attr = &_POSIX_Mutex_Default_attributes; /* Check for NULL mutex */ if ( !mutex ) 10be06: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10be09: 85 f6 test %esi,%esi <== NOT EXECUTED 10be0b: 0f 84 c3 00 00 00 je 10bed4 <== NOT EXECUTED break; } } #endif if ( !the_attr->is_initialized ) 10be11: 8b 0b mov (%ebx),%ecx <== NOT EXECUTED 10be13: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10be15: 0f 84 b9 00 00 00 je 10bed4 <== NOT EXECUTED /* * XXX: Be careful about attributes when global!!! */ assert( the_attr->process_shared == PTHREAD_PROCESS_PRIVATE ); 10be1b: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 10be1e: 85 d2 test %edx,%edx <== NOT EXECUTED 10be20: 0f 85 ee 00 00 00 jne 10bf14 <== NOT EXECUTED /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 10be26: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10be29: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10be2c: 0f 84 be 00 00 00 je 10bef0 <== NOT EXECUTED 10be32: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10be35: 0f 84 c1 00 00 00 je 10befc <== NOT EXECUTED 10be3b: 85 c0 test %eax,%eax <== NOT EXECUTED 10be3d: 0f 85 91 00 00 00 jne 10bed4 <== NOT EXECUTED 10be43: 31 ff xor %edi,%edi <== NOT EXECUTED break; default: return EINVAL; } if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) ) 10be45: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10be48: 48 dec %eax <== NOT EXECUTED 10be49: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10be4e: 0f 87 80 00 00 00 ja 10bed4 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10be54: a1 98 51 12 00 mov 0x125198,%eax <== NOT EXECUTED 10be59: 40 inc %eax <== NOT EXECUTED 10be5a: a3 98 51 12 00 mov %eax,0x125198 <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 10be5f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10be62: 68 a0 55 12 00 push $0x1255a0 <== NOT EXECUTED 10be67: e8 b0 27 00 00 call 10e61c <_Objects_Allocate> <== NOT EXECUTED 10be6c: 89 c6 mov %eax,%esi <== NOT EXECUTED _Thread_Disable_dispatch(); the_mutex = _POSIX_Mutex_Allocate(); if ( !the_mutex ) { 10be6e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10be71: 85 c0 test %eax,%eax <== NOT EXECUTED 10be73: 0f 84 8f 00 00 00 je 10bf08 <== NOT EXECUTED _Thread_Enable_dispatch(); return EAGAIN; } the_mutex->process_shared = the_attr->process_shared; 10be79: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10be7c: 89 46 10 mov %eax,0x10(%esi) <== NOT EXECUTED the_mutex_attr = &the_mutex->Mutex.Attributes; if ( the_attr->recursive ) the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 10be7f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10be81: 83 7b 10 00 cmpl $0x0,0x10(%ebx) <== NOT EXECUTED 10be85: 0f 94 c0 sete %al <== NOT EXECUTED 10be88: 89 46 54 mov %eax,0x54(%esi) <== NOT EXECUTED else the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR; the_mutex_attr->only_owner_release = TRUE; 10be8b: c6 46 58 01 movb $0x1,0x58(%esi) <== NOT EXECUTED the_mutex_attr->priority_ceiling = 10be8f: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10be94: 2b 43 08 sub 0x8(%ebx),%eax <== NOT EXECUTED 10be97: 89 46 60 mov %eax,0x60(%esi) <== NOT EXECUTED _POSIX_Priority_To_core( the_attr->prio_ceiling ); the_mutex_attr->discipline = the_discipline; 10be9a: 89 7e 5c mov %edi,0x5c(%esi) <== NOT EXECUTED /* * Must be initialized to unlocked. */ _CORE_mutex_Initialize( 10be9d: 50 push %eax <== NOT EXECUTED 10be9e: 6a 01 push $0x1 <== NOT EXECUTED 10bea0: 8d 46 54 lea 0x54(%esi),%eax <== NOT EXECUTED 10bea3: 50 push %eax <== NOT EXECUTED 10bea4: 8d 46 14 lea 0x14(%esi),%eax <== NOT EXECUTED 10bea7: 50 push %eax <== NOT EXECUTED 10bea8: e8 53 20 00 00 call 10df00 <_CORE_mutex_Initialize> <== NOT EXECUTED 10bead: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED 10beb0: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10beb3: a1 bc 55 12 00 mov 0x1255bc,%eax <== NOT EXECUTED 10beb8: 89 34 90 mov %esi,(%eax,%edx,4) <== NOT EXECUTED 10bebb: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) <== NOT EXECUTED CORE_MUTEX_UNLOCKED ); _Objects_Open_u32( &_POSIX_Mutex_Information, &the_mutex->Object, 0 ); *mutex = the_mutex->Object.id; 10bec2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bec5: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10bec7: e8 88 34 00 00 call 10f354 <_Thread_Enable_dispatch> <== NOT EXECUTED 10becc: 31 c0 xor %eax,%eax <== NOT EXECUTED 10bece: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bed1: eb 06 jmp 10bed9 <== NOT EXECUTED 10bed3: 90 nop <== NOT EXECUTED return 0; 10bed4: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10bed9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bedc: 5b pop %ebx <== NOT EXECUTED 10bedd: 5e pop %esi <== NOT EXECUTED 10bede: 5f pop %edi <== NOT EXECUTED 10bedf: c9 leave <== NOT EXECUTED 10bee0: c3 ret <== NOT EXECUTED 10bee1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED #if 0 register POSIX_Mutex_Control *mutex_in_use; Objects_Locations location; #endif if ( attr ) the_attr = attr; 10bee4: bb e8 e6 11 00 mov $0x11e6e8,%ebx <== NOT EXECUTED 10bee9: e9 18 ff ff ff jmp 10be06 <== NOT EXECUTED 10beee: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 10bef0: bf 02 00 00 00 mov $0x2,%edi <== NOT EXECUTED 10bef5: e9 4b ff ff ff jmp 10be45 <== NOT EXECUTED 10befa: 66 90 xchg %ax,%ax <== NOT EXECUTED 10befc: bf 03 00 00 00 mov $0x3,%edi <== NOT EXECUTED 10bf01: e9 3f ff ff ff jmp 10be45 <== NOT EXECUTED 10bf06: 66 90 xchg %ax,%ax <== NOT EXECUTED _Thread_Disable_dispatch(); the_mutex = _POSIX_Mutex_Allocate(); if ( !the_mutex ) { _Thread_Enable_dispatch(); 10bf08: e8 47 34 00 00 call 10f354 <_Thread_Enable_dispatch> <== NOT EXECUTED 10bf0d: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 10bf12: eb c5 jmp 10bed9 <== NOT EXECUTED /* * XXX: Be careful about attributes when global!!! */ assert( the_attr->process_shared == PTHREAD_PROCESS_PRIVATE ); 10bf14: 68 fc e6 11 00 push $0x11e6fc <== NOT EXECUTED 10bf19: 68 76 e7 11 00 push $0x11e776 <== NOT EXECUTED 10bf1e: 6a 68 push $0x68 <== NOT EXECUTED 10bf20: 68 30 e7 11 00 push $0x11e730 <== NOT EXECUTED 10bf25: e8 ae ce ff ff call 108dd8 <__assert_func> <== NOT EXECUTED 0010bf2c : */ int pthread_mutex_lock( pthread_mutex_t *mutex ) { 10bf2c: 55 push %ebp <== NOT EXECUTED 10bf2d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bf2f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return _POSIX_Mutex_Lock_support( mutex, TRUE, THREAD_QUEUE_WAIT_FOREVER ); 10bf32: 6a 00 push $0x0 <== NOT EXECUTED 10bf34: 6a 01 push $0x1 <== NOT EXECUTED 10bf36: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bf39: e8 02 00 00 00 call 10bf40 <_POSIX_Mutex_Lock_support> <== NOT EXECUTED } 10bf3e: c9 leave <== NOT EXECUTED 10bf3f: c3 ret <== NOT EXECUTED 0010bfa4 : int pthread_mutex_setprioceiling( pthread_mutex_t *mutex, int prioceiling, int *old_ceiling ) { 10bfa4: 55 push %ebp <== NOT EXECUTED 10bfa5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bfa7: 56 push %esi <== NOT EXECUTED 10bfa8: 53 push %ebx <== NOT EXECUTED 10bfa9: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10bfac: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; Priority_Control the_priority; int status; if ( !old_ceiling ) 10bfaf: 85 f6 test %esi,%esi <== NOT EXECUTED 10bfb1: 74 0b je 10bfbe <== NOT EXECUTED return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) 10bfb3: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10bfb6: 48 dec %eax <== NOT EXECUTED 10bfb7: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10bfbc: 76 0e jbe 10bfcc <== NOT EXECUTED &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); return 0; 10bfbe: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10bfc3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bfc5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10bfc8: 5b pop %ebx <== NOT EXECUTED 10bfc9: 5e pop %esi <== NOT EXECUTED 10bfca: c9 leave <== NOT EXECUTED 10bfcb: c3 ret <== NOT EXECUTED /* * Must acquire the mutex before we can change it's ceiling */ status = pthread_mutex_lock( mutex ); 10bfcc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bfcf: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bfd2: e8 55 ff ff ff call 10bf2c <== NOT EXECUTED 10bfd7: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( status ) 10bfd9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bfdc: 85 c0 test %eax,%eax <== NOT EXECUTED 10bfde: 75 e3 jne 10bfc3 <== NOT EXECUTED return status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); 10bfe0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bfe3: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10bfe6: 50 push %eax <== NOT EXECUTED 10bfe7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bfea: e8 61 fd ff ff call 10bd50 <_POSIX_Mutex_Get> <== NOT EXECUTED 10bfef: 89 c1 mov %eax,%ecx <== NOT EXECUTED switch ( location ) { 10bff1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bff4: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 10bff7: 85 d2 test %edx,%edx <== NOT EXECUTED 10bff9: 75 c3 jne 10bfbe <== NOT EXECUTED case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( 10bffb: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10c000: 89 c2 mov %eax,%edx <== NOT EXECUTED 10c002: 2b 51 60 sub 0x60(%ecx),%edx <== NOT EXECUTED 10c005: 89 16 mov %edx,(%esi) <== NOT EXECUTED the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; 10c007: 2b 45 0c sub 0xc(%ebp),%eax <== NOT EXECUTED 10c00a: 89 41 60 mov %eax,0x60(%ecx) <== NOT EXECUTED _CORE_mutex_Surrender( 10c00d: 50 push %eax <== NOT EXECUTED 10c00e: 6a 00 push $0x0 <== NOT EXECUTED 10c010: ff 71 08 pushl 0x8(%ecx) <== NOT EXECUTED 10c013: 8d 41 14 lea 0x14(%ecx),%eax <== NOT EXECUTED 10c016: 50 push %eax <== NOT EXECUTED 10c017: e8 78 20 00 00 call 10e094 <_CORE_mutex_Surrender> <== NOT EXECUTED &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 10c01c: e8 33 33 00 00 call 10f354 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c021: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c024: eb 9d jmp 10bfc3 <== NOT EXECUTED 0010c028 : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 10c028: 55 push %ebp <== NOT EXECUTED 10c029: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c02b: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10c02e: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10c031: 50 push %eax <== NOT EXECUTED 10c032: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c035: e8 aa 00 00 00 call 10c0e4 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED switch ( status ) { 10c03a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c03d: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10c040: 76 05 jbe 10c047 <== NOT EXECUTED 10c042: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10c045: 74 15 je 10c05c <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } lock_status = _POSIX_Mutex_Lock_support( 10c047: 52 push %edx <== NOT EXECUTED 10c048: ff 75 fc pushl -0x4(%ebp) <== NOT EXECUTED 10c04b: 6a 00 push $0x0 <== NOT EXECUTED 10c04d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c050: e8 eb fe ff ff call 10bf40 <_POSIX_Mutex_Lock_support> <== NOT EXECUTED 10c055: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } } return lock_status; } 10c058: c9 leave <== NOT EXECUTED 10c059: c3 ret <== NOT EXECUTED 10c05a: 66 90 xchg %ax,%ax <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } lock_status = _POSIX_Mutex_Lock_support( 10c05c: 50 push %eax <== NOT EXECUTED 10c05d: ff 75 fc pushl -0x4(%ebp) <== NOT EXECUTED 10c060: 6a 01 push $0x1 <== NOT EXECUTED 10c062: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c065: e8 d6 fe ff ff call 10bf40 <_POSIX_Mutex_Lock_support> <== NOT EXECUTED 10c06a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } } return lock_status; } 10c06d: c9 leave <== NOT EXECUTED 10c06e: c3 ret <== NOT EXECUTED 0010c080 : */ int pthread_mutex_trylock( pthread_mutex_t *mutex ) { 10c080: 55 push %ebp <== NOT EXECUTED 10c081: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c083: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return _POSIX_Mutex_Lock_support( mutex, FALSE, THREAD_QUEUE_WAIT_FOREVER ); 10c086: 6a 00 push $0x0 <== NOT EXECUTED 10c088: 6a 00 push $0x0 <== NOT EXECUTED 10c08a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c08d: e8 ae fe ff ff call 10bf40 <_POSIX_Mutex_Lock_support> <== NOT EXECUTED } 10c092: c9 leave <== NOT EXECUTED 10c093: c3 ret <== NOT EXECUTED 0010c094 : */ int pthread_mutex_unlock( pthread_mutex_t *mutex ) { 10c094: 55 push %ebp <== NOT EXECUTED 10c095: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c097: 53 push %ebx <== NOT EXECUTED 10c098: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; CORE_mutex_Status status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); 10c09b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10c09e: 50 push %eax <== NOT EXECUTED 10c09f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c0a2: e8 a9 fc ff ff call 10bd50 <_POSIX_Mutex_Get> <== NOT EXECUTED switch ( location ) { 10c0a7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c0aa: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 10c0ad: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10c0af: 75 27 jne 10c0d8 <== NOT EXECUTED case OBJECTS_LOCAL: status = _CORE_mutex_Surrender( 10c0b1: 52 push %edx <== NOT EXECUTED 10c0b2: 6a 00 push $0x0 <== NOT EXECUTED 10c0b4: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10c0b7: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 10c0ba: 50 push %eax <== NOT EXECUTED 10c0bb: e8 d4 1f 00 00 call 10e094 <_CORE_mutex_Surrender> <== NOT EXECUTED 10c0c0: 89 c3 mov %eax,%ebx <== NOT EXECUTED &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 10c0c2: e8 8d 32 00 00 call 10f354 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_Mutex_Translate_core_mutex_return_code( status ); 10c0c7: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10c0ca: e8 a1 ff ff ff call 10c070 <_POSIX_Mutex_Translate_core_mutex_return_code> <== NOT EXECUTED 10c0cf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10c0d2: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c0d5: c9 leave <== NOT EXECUTED 10c0d6: c3 ret <== NOT EXECUTED 10c0d7: 90 nop <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; CORE_mutex_Status status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 10c0d8: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10c0dd: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c0e0: c9 leave <== NOT EXECUTED 10c0e1: c3 ret <== NOT EXECUTED 0010bb24 : */ int pthread_mutexattr_destroy( pthread_mutexattr_t *attr ) { 10bb24: 55 push %ebp <== NOT EXECUTED 10bb25: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb27: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10bb2a: 85 c0 test %eax,%eax <== NOT EXECUTED 10bb2c: 74 12 je 10bb40 <== NOT EXECUTED 10bb2e: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10bb30: 85 d2 test %edx,%edx <== NOT EXECUTED 10bb32: 74 0c je 10bb40 <== NOT EXECUTED return EINVAL; attr->is_initialized = FALSE; 10bb34: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 10bb3a: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10bb3c: c9 leave <== NOT EXECUTED 10bb3d: c3 ret <== NOT EXECUTED 10bb3e: 66 90 xchg %ax,%ax <== NOT EXECUTED { if ( !attr || !attr->is_initialized ) return EINVAL; attr->is_initialized = FALSE; return 0; 10bb40: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10bb45: c9 leave <== NOT EXECUTED 10bb46: c3 ret <== NOT EXECUTED 0010bb48 : int pthread_mutexattr_getprioceiling( const pthread_mutexattr_t *attr, int *prioceiling ) { 10bb48: 55 push %ebp <== NOT EXECUTED 10bb49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb4b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bb4e: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !prioceiling ) 10bb51: 85 c0 test %eax,%eax <== NOT EXECUTED 10bb53: 74 13 je 10bb68 <== NOT EXECUTED 10bb55: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10bb57: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bb59: 74 0d je 10bb68 <== NOT EXECUTED 10bb5b: 85 d2 test %edx,%edx <== NOT EXECUTED 10bb5d: 74 09 je 10bb68 <== NOT EXECUTED return EINVAL; *prioceiling = attr->prio_ceiling; 10bb5f: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10bb62: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10bb64: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10bb66: c9 leave <== NOT EXECUTED 10bb67: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !prioceiling ) return EINVAL; *prioceiling = attr->prio_ceiling; return 0; 10bb68: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10bb6d: c9 leave <== NOT EXECUTED 10bb6e: c3 ret <== NOT EXECUTED 0010bb70 : int pthread_mutexattr_getprotocol( const pthread_mutexattr_t *attr, int *protocol ) { 10bb70: 55 push %ebp <== NOT EXECUTED 10bb71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb73: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bb76: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !protocol ) 10bb79: 85 c0 test %eax,%eax <== NOT EXECUTED 10bb7b: 74 13 je 10bb90 <== NOT EXECUTED 10bb7d: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10bb7f: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bb81: 74 0d je 10bb90 <== NOT EXECUTED 10bb83: 85 d2 test %edx,%edx <== NOT EXECUTED 10bb85: 74 09 je 10bb90 <== NOT EXECUTED return EINVAL; *protocol = attr->protocol; 10bb87: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10bb8a: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10bb8c: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10bb8e: c9 leave <== NOT EXECUTED 10bb8f: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !protocol ) return EINVAL; *protocol = attr->protocol; return 0; 10bb90: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10bb95: c9 leave <== NOT EXECUTED 10bb96: c3 ret <== NOT EXECUTED 0010bb98 : int pthread_mutexattr_getpshared( const pthread_mutexattr_t *attr, int *pshared ) { 10bb98: 55 push %ebp <== NOT EXECUTED 10bb99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb9b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bb9e: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !pshared ) 10bba1: 85 c0 test %eax,%eax <== NOT EXECUTED 10bba3: 74 13 je 10bbb8 <== NOT EXECUTED 10bba5: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10bba7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bba9: 74 0d je 10bbb8 <== NOT EXECUTED 10bbab: 85 d2 test %edx,%edx <== NOT EXECUTED 10bbad: 74 09 je 10bbb8 <== NOT EXECUTED return EINVAL; *pshared = attr->process_shared; 10bbaf: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10bbb2: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10bbb4: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10bbb6: c9 leave <== NOT EXECUTED 10bbb7: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !pshared ) return EINVAL; *pshared = attr->process_shared; return 0; 10bbb8: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10bbbd: c9 leave <== NOT EXECUTED 10bbbe: c3 ret <== NOT EXECUTED 0010bbc0 : */ int pthread_mutexattr_init( pthread_mutexattr_t *attr ) { 10bbc0: 55 push %ebp <== NOT EXECUTED 10bbc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bbc3: 57 push %edi <== NOT EXECUTED 10bbc4: 56 push %esi <== NOT EXECUTED 10bbc5: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bbc8: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED if ( !attr ) 10bbcb: 85 ff test %edi,%edi <== NOT EXECUTED 10bbcd: 74 15 je 10bbe4 <== NOT EXECUTED return EINVAL; *attr = _POSIX_Mutex_Default_attributes; 10bbcf: be e8 e6 11 00 mov $0x11e6e8,%esi <== NOT EXECUTED 10bbd4: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 10bbd9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10bbdb: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10bbdd: 5a pop %edx <== NOT EXECUTED 10bbde: 5e pop %esi <== NOT EXECUTED 10bbdf: 5f pop %edi <== NOT EXECUTED 10bbe0: c9 leave <== NOT EXECUTED 10bbe1: c3 ret <== NOT EXECUTED 10bbe2: 66 90 xchg %ax,%ax <== NOT EXECUTED int pthread_mutexattr_init( pthread_mutexattr_t *attr ) { if ( !attr ) 10bbe4: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED return EINVAL; *attr = _POSIX_Mutex_Default_attributes; return 0; } 10bbe9: 5a pop %edx <== NOT EXECUTED 10bbea: 5e pop %esi <== NOT EXECUTED 10bbeb: 5f pop %edi <== NOT EXECUTED 10bbec: c9 leave <== NOT EXECUTED 10bbed: c3 ret <== NOT EXECUTED 0010bbf0 : int pthread_mutexattr_setprioceiling( pthread_mutexattr_t *attr, int prioceiling ) { 10bbf0: 55 push %ebp <== NOT EXECUTED 10bbf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bbf3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10bbf6: 85 d2 test %edx,%edx <== NOT EXECUTED 10bbf8: 74 1e je 10bc18 <== NOT EXECUTED 10bbfa: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10bbfc: 85 c0 test %eax,%eax <== NOT EXECUTED 10bbfe: 74 18 je 10bc18 <== NOT EXECUTED return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) 10bc00: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10bc03: 48 dec %eax <== NOT EXECUTED 10bc04: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10bc09: 77 0d ja 10bc18 <== NOT EXECUTED return EINVAL; attr->prio_ceiling = prioceiling; 10bc0b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10bc0e: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED 10bc11: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10bc13: c9 leave <== NOT EXECUTED 10bc14: c3 ret <== NOT EXECUTED 10bc15: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !_POSIX_Priority_Is_valid( prioceiling ) ) return EINVAL; attr->prio_ceiling = prioceiling; return 0; 10bc18: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10bc1d: c9 leave <== NOT EXECUTED 10bc1e: c3 ret <== NOT EXECUTED 0010bc20 : int pthread_mutexattr_setprotocol( pthread_mutexattr_t *attr, int protocol ) { 10bc20: 55 push %ebp <== NOT EXECUTED 10bc21: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc23: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10bc26: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc28: 74 0c je 10bc36 <== NOT EXECUTED 10bc2a: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10bc2c: 85 d2 test %edx,%edx <== NOT EXECUTED 10bc2e: 74 06 je 10bc36 <== NOT EXECUTED return EINVAL; switch ( protocol ) { 10bc30: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) <== NOT EXECUTED 10bc34: 76 0a jbe 10bc40 <== NOT EXECUTED case PTHREAD_PRIO_NONE: case PTHREAD_PRIO_INHERIT: case PTHREAD_PRIO_PROTECT: attr->protocol = protocol; return 0; 10bc36: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10bc3b: c9 leave <== NOT EXECUTED 10bc3c: c3 ret <== NOT EXECUTED 10bc3d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED switch ( protocol ) { case PTHREAD_PRIO_NONE: case PTHREAD_PRIO_INHERIT: case PTHREAD_PRIO_PROTECT: attr->protocol = protocol; 10bc40: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10bc43: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED 10bc46: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; default: return EINVAL; } } 10bc48: c9 leave <== NOT EXECUTED 10bc49: c3 ret <== NOT EXECUTED 0010bc4c : int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { 10bc4c: 55 push %ebp <== NOT EXECUTED 10bc4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc4f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10bc52: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc54: 74 0c je 10bc62 <== NOT EXECUTED 10bc56: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10bc58: 85 d2 test %edx,%edx <== NOT EXECUTED 10bc5a: 74 06 je 10bc62 <== NOT EXECUTED return EINVAL; switch ( pshared ) { 10bc5c: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10bc60: 76 0a jbe 10bc6c <== NOT EXECUTED case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; return 0; 10bc62: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10bc67: c9 leave <== NOT EXECUTED 10bc68: c3 ret <== NOT EXECUTED 10bc69: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return EINVAL; switch ( pshared ) { case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10bc6c: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10bc6f: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 10bc72: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; default: return EINVAL; } } 10bc74: c9 leave <== NOT EXECUTED 10bc75: c3 ret <== NOT EXECUTED 0010b3ec : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { 10b3ec: 55 push %ebp <== NOT EXECUTED 10b3ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b3ef: 56 push %esi <== NOT EXECUTED 10b3f0: 53 push %ebx <== NOT EXECUTED 10b3f1: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10b3f4: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( !once_control || !init_routine ) 10b3f7: 85 db test %ebx,%ebx <== NOT EXECUTED 10b3f9: 74 55 je 10b450 <== NOT EXECUTED 10b3fb: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b3fe: 85 c0 test %eax,%eax <== NOT EXECUTED 10b400: 74 4e je 10b450 <== NOT EXECUTED return EINVAL; if ( !once_control->init_executed ) { 10b402: 8b 73 04 mov 0x4(%ebx),%esi <== NOT EXECUTED 10b405: 85 f6 test %esi,%esi <== NOT EXECUTED 10b407: 74 0b je 10b414 <== NOT EXECUTED 10b409: 31 c0 xor %eax,%eax <== NOT EXECUTED (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; } 10b40b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b40e: 5b pop %ebx <== NOT EXECUTED 10b40f: 5e pop %esi <== NOT EXECUTED 10b410: c9 leave <== NOT EXECUTED 10b411: c3 ret <== NOT EXECUTED 10b412: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !once_control || !init_routine ) return EINVAL; if ( !once_control->init_executed ) { rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 10b414: 51 push %ecx <== NOT EXECUTED 10b415: 8d 75 f4 lea -0xc(%ebp),%esi <== NOT EXECUTED 10b418: 56 push %esi <== NOT EXECUTED 10b419: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 10b41e: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 10b423: e8 30 0e 00 00 call 10c258 <== NOT EXECUTED if ( !once_control->init_executed ) { 10b428: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b42b: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 10b42e: 85 d2 test %edx,%edx <== NOT EXECUTED 10b430: 74 2a je 10b45c <== NOT EXECUTED once_control->is_initialized = TRUE; once_control->init_executed = TRUE; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 10b432: 50 push %eax <== NOT EXECUTED 10b433: 56 push %esi <== NOT EXECUTED 10b434: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 10b439: ff 75 f4 pushl -0xc(%ebp) <== NOT EXECUTED 10b43c: e8 17 0e 00 00 call 10c258 <== NOT EXECUTED 10b441: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b443: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 10b446: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b449: 5b pop %ebx <== NOT EXECUTED 10b44a: 5e pop %esi <== NOT EXECUTED 10b44b: c9 leave <== NOT EXECUTED 10b44c: c3 ret <== NOT EXECUTED 10b44d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !once_control->init_executed ) { once_control->is_initialized = TRUE; once_control->init_executed = TRUE; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 10b450: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } return 0; } 10b455: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b458: 5b pop %ebx <== NOT EXECUTED 10b459: 5e pop %esi <== NOT EXECUTED 10b45a: c9 leave <== NOT EXECUTED 10b45b: c3 ret <== NOT EXECUTED if ( !once_control->init_executed ) { rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); if ( !once_control->init_executed ) { once_control->is_initialized = TRUE; 10b45c: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED once_control->init_executed = TRUE; 10b462: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) <== NOT EXECUTED (*init_routine)(); 10b469: ff 55 0c call *0xc(%ebp) <== NOT EXECUTED 10b46c: eb c4 jmp 10b432 <== NOT EXECUTED 0010aad8 : */ int pthread_rwlock_destroy( pthread_rwlock_t *rwlock ) { 10aad8: 55 push %ebp <== NOT EXECUTED 10aad9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aadb: 53 push %ebx <== NOT EXECUTED 10aadc: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10aadf: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_RWLock_Control *the_rwlock = NULL; Objects_Locations location; if ( !rwlock ) 10aae2: 85 d2 test %edx,%edx <== NOT EXECUTED 10aae4: 74 42 je 10ab28 <== 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 10aae6: 53 push %ebx <== NOT EXECUTED 10aae7: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10aaea: 50 push %eax <== NOT EXECUTED 10aaeb: ff 32 pushl (%edx) <== NOT EXECUTED 10aaed: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10aaf2: e8 55 2e 00 00 call 10d94c <_Objects_Get> <== NOT EXECUTED 10aaf7: 89 c3 mov %eax,%ebx <== NOT EXECUTED return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 10aaf9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aafc: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 10aaff: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ab01: 75 25 jne 10ab28 <== NOT EXECUTED case OBJECTS_LOCAL: /* * If there is at least one thread waiting, then do not delete it. */ if ( _Thread_queue_First( &the_rwlock->RWLock.Wait_queue ) != NULL ) { 10ab03: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab06: 8d 40 10 lea 0x10(%eax),%eax <== NOT EXECUTED 10ab09: 50 push %eax <== NOT EXECUTED 10ab0a: e8 7d 3e 00 00 call 10e98c <_Thread_queue_First> <== NOT EXECUTED 10ab0f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ab12: 85 c0 test %eax,%eax <== NOT EXECUTED 10ab14: 74 1e je 10ab34 <== NOT EXECUTED _Thread_Enable_dispatch(); 10ab16: e8 75 36 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ab1b: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ab20: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ab23: c9 leave <== NOT EXECUTED 10ab24: c3 ret <== NOT EXECUTED 10ab25: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object ); _POSIX_RWLock_Free( the_rwlock ); _Thread_Enable_dispatch(); return 0; 10ab28: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ab2d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ab30: c9 leave <== NOT EXECUTED 10ab31: c3 ret <== NOT EXECUTED 10ab32: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * POSIX doesn't require behavior when it is locked. */ _Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object ); 10ab34: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ab37: 53 push %ebx <== NOT EXECUTED 10ab38: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10ab3d: e8 96 29 00 00 call 10d4d8 <_Objects_Close> <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon * @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 * 10ab42: 58 pop %eax <== NOT EXECUTED 10ab43: 5a pop %edx <== NOT EXECUTED 10ab44: 53 push %ebx <== NOT EXECUTED 10ab45: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10ab4a: e8 c9 2c 00 00 call 10d818 <_Objects_Free> <== NOT EXECUTED _POSIX_RWLock_Free( the_rwlock ); _Thread_Enable_dispatch(); 10ab4f: e8 3c 36 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ab54: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ab56: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ab59: eb d2 jmp 10ab2d <== NOT EXECUTED 0010ab5c : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 10ab5c: 55 push %ebp <== NOT EXECUTED 10ab5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ab5f: 56 push %esi <== NOT EXECUTED 10ab60: 53 push %ebx <== NOT EXECUTED 10ab61: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ab64: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10ab67: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 10ab6a: 85 f6 test %esi,%esi <== NOT EXECUTED 10ab6c: 74 15 je 10ab83 <== NOT EXECUTED return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10ab6e: 85 c0 test %eax,%eax <== NOT EXECUTED 10ab70: 0f 84 82 00 00 00 je 10abf8 <== NOT EXECUTED } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 10ab76: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10ab78: 85 d2 test %edx,%edx <== NOT EXECUTED 10ab7a: 74 07 je 10ab83 <== NOT EXECUTED return EINVAL; switch ( the_attr->process_shared ) { 10ab7c: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10ab7f: 85 c0 test %eax,%eax <== NOT EXECUTED 10ab81: 74 0d je 10ab90 <== NOT EXECUTED ); *rwlock = the_rwlock->Object.id; _Thread_Enable_dispatch(); return 0; 10ab83: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10ab88: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ab8b: 5b pop %ebx <== NOT EXECUTED 10ab8c: 5e pop %esi <== NOT EXECUTED 10ab8d: c9 leave <== NOT EXECUTED 10ab8e: c3 ret <== NOT EXECUTED 10ab8f: 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 10ab90: a1 18 20 12 00 mov 0x122018,%eax <== NOT EXECUTED 10ab95: 40 inc %eax <== NOT EXECUTED 10ab96: a3 18 20 12 00 mov %eax,0x122018 <== NOT EXECUTED */ /**@{*/ #ifdef __cplusplus extern "C" { #endif 10ab9b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab9e: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10aba3: e8 b0 28 00 00 call 10d458 <_Objects_Allocate> <== NOT EXECUTED 10aba8: 89 c3 mov %eax,%ebx <== NOT EXECUTED */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 10abaa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10abad: 85 c0 test %eax,%eax <== NOT EXECUTED 10abaf: 74 3b je 10abec <== NOT EXECUTED _Thread_Enable_dispatch(); return EAGAIN; } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 10abb1: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10abb4: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10abb7: 50 push %eax <== NOT EXECUTED 10abb8: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10abbb: 50 push %eax <== NOT EXECUTED 10abbc: e8 d7 21 00 00 call 10cd98 <_CORE_RWLock_Initialize> <== NOT EXECUTED 10abc1: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10abc4: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10abc7: a1 bc 22 12 00 mov 0x1222bc,%eax <== NOT EXECUTED 10abcc: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10abcf: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 10abd6: 89 0e mov %ecx,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10abd8: e8 b3 35 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED 10abdd: 31 c0 xor %eax,%eax <== NOT EXECUTED 10abdf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10abe2: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10abe5: 5b pop %ebx <== NOT EXECUTED 10abe6: 5e pop %esi <== NOT EXECUTED 10abe7: c9 leave <== NOT EXECUTED 10abe8: c3 ret <== NOT EXECUTED 10abe9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { _Thread_Enable_dispatch(); 10abec: e8 9f 35 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED 10abf1: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 10abf6: eb 90 jmp 10ab88 <== NOT EXECUTED * If the user passed in NULL, use the default attributes */ if ( attr ) { the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 10abf8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10abfb: 8d 5d ec lea -0x14(%ebp),%ebx <== NOT EXECUTED 10abfe: 53 push %ebx <== NOT EXECUTED 10abff: e8 24 0a 00 00 call 10b628 <== NOT EXECUTED 10ac04: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10ac06: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac09: e9 68 ff ff ff jmp 10ab76 <== NOT EXECUTED 0010ac10 : */ int pthread_rwlock_rdlock( pthread_rwlock_t *rwlock ) { 10ac10: 55 push %ebp <== NOT EXECUTED 10ac11: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac13: 53 push %ebx <== NOT EXECUTED 10ac14: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10ac17: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 10ac1a: 85 db test %ebx,%ebx <== NOT EXECUTED 10ac1c: 74 1b je 10ac39 <== 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 10ac1e: 51 push %ecx <== NOT EXECUTED 10ac1f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10ac22: 50 push %eax <== NOT EXECUTED 10ac23: ff 33 pushl (%ebx) <== NOT EXECUTED 10ac25: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10ac2a: e8 1d 2d 00 00 call 10d94c <_Objects_Get> <== NOT EXECUTED return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 10ac2f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac32: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10ac35: 85 d2 test %edx,%edx <== NOT EXECUTED 10ac37: 74 0b je 10ac44 <== NOT EXECUTED 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 10ac39: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ac3e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ac41: c9 leave <== NOT EXECUTED 10ac42: c3 ret <== NOT EXECUTED 10ac43: 90 nop <== NOT EXECUTED the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 10ac44: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ac47: 6a 00 push $0x0 <== NOT EXECUTED 10ac49: 6a 00 push $0x0 <== NOT EXECUTED 10ac4b: 6a 01 push $0x1 <== NOT EXECUTED 10ac4d: ff 33 pushl (%ebx) <== NOT EXECUTED 10ac4f: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10ac52: 50 push %eax <== NOT EXECUTED 10ac53: e8 74 21 00 00 call 10cdcc <_CORE_RWLock_Obtain_for_reading> <== NOT EXECUTED TRUE, /* we are willing to wait forever */ 0, NULL ); _Thread_Enable_dispatch(); 10ac58: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10ac5b: e8 30 35 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( 10ac60: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ac63: a1 dc 20 12 00 mov 0x1220dc,%eax <== NOT EXECUTED 10ac68: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10ac6b: e8 90 01 00 00 call 10ae00 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 10ac70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ac73: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ac76: c9 leave <== NOT EXECUTED 10ac77: c3 ret <== NOT EXECUTED 0010ac78 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10ac78: 55 push %ebp <== NOT EXECUTED 10ac79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac7b: 57 push %edi <== NOT EXECUTED 10ac7c: 56 push %esi <== NOT EXECUTED 10ac7d: 53 push %ebx <== NOT EXECUTED 10ac7e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10ac81: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Objects_Locations location; Watchdog_Interval ticks; bool do_wait; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 10ac84: 85 f6 test %esi,%esi <== NOT EXECUTED 10ac86: 74 78 je 10ad00 <== NOT EXECUTED * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10ac88: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ac8b: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10ac8e: 50 push %eax <== NOT EXECUTED 10ac8f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10ac92: e8 7d 63 00 00 call 111014 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 10ac97: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch (status) { 10ac99: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac9c: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10ac9f: 76 6f jbe 10ad10 <== NOT EXECUTED 10aca1: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10aca4: 75 05 jne 10acab <== NOT EXECUTED 10aca6: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED 10acab: 52 push %edx <== NOT EXECUTED 10acac: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10acaf: 50 push %eax <== NOT EXECUTED 10acb0: ff 36 pushl (%esi) <== NOT EXECUTED 10acb2: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10acb7: e8 90 2c 00 00 call 10d94c <_Objects_Get> <== NOT EXECUTED 10acbc: 89 c2 mov %eax,%edx <== NOT EXECUTED do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 10acbe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10acc1: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10acc4: 85 c0 test %eax,%eax <== NOT EXECUTED 10acc6: 75 38 jne 10ad00 <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 10acc8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10accb: 6a 00 push $0x0 <== NOT EXECUTED 10accd: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10acd0: 89 f9 mov %edi,%ecx <== NOT EXECUTED 10acd2: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 10acd5: 50 push %eax <== NOT EXECUTED 10acd6: ff 36 pushl (%esi) <== NOT EXECUTED 10acd8: 8d 42 10 lea 0x10(%edx),%eax <== NOT EXECUTED 10acdb: 50 push %eax <== NOT EXECUTED 10acdc: e8 eb 20 00 00 call 10cdcc <_CORE_RWLock_Obtain_for_reading> <== NOT EXECUTED do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10ace1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10ace4: e8 a7 34 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( !do_wait && 10ace9: 89 f8 mov %edi,%eax <== NOT EXECUTED 10aceb: 84 c0 test %al,%al <== NOT EXECUTED 10aced: 75 25 jne 10ad14 <== NOT EXECUTED 10acef: a1 dc 20 12 00 mov 0x1220dc,%eax <== NOT EXECUTED 10acf4: 83 78 34 02 cmpl $0x2,0x34(%eax) <== NOT EXECUTED 10acf8: 75 1f jne 10ad19 <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 10acfa: 85 db test %ebx,%ebx <== NOT EXECUTED 10acfc: 75 32 jne 10ad30 <== NOT EXECUTED 10acfe: 66 90 xchg %ax,%ax <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: break; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10ad00: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ad05: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ad08: 5b pop %ebx <== NOT EXECUTED 10ad09: 5e pop %esi <== NOT EXECUTED 10ad0a: 5f pop %edi <== NOT EXECUTED 10ad0b: c9 leave <== NOT EXECUTED 10ad0c: c3 ret <== NOT EXECUTED 10ad0d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); switch (status) { 10ad10: 31 ff xor %edi,%edi <== NOT EXECUTED 10ad12: eb 97 jmp 10acab <== NOT EXECUTED 10ad14: a1 dc 20 12 00 mov 0x1220dc,%eax <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: break; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10ad19: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad1c: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10ad1f: e8 dc 00 00 00 call 10ae00 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 10ad24: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ad27: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ad2a: 5b pop %ebx <== NOT EXECUTED 10ad2b: 5e pop %esi <== NOT EXECUTED 10ad2c: 5f pop %edi <== NOT EXECUTED 10ad2d: c9 leave <== NOT EXECUTED 10ad2e: c3 ret <== NOT EXECUTED 10ad2f: 90 nop <== NOT EXECUTED ); _Thread_Enable_dispatch(); if ( !do_wait && (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 10ad30: 83 fb 02 cmp $0x2,%ebx <== NOT EXECUTED 10ad33: 77 e4 ja 10ad19 <== NOT EXECUTED 10ad35: b8 74 00 00 00 mov $0x74,%eax <== NOT EXECUTED 10ad3a: eb c9 jmp 10ad05 <== NOT EXECUTED 0010ad3c : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10ad3c: 55 push %ebp <== NOT EXECUTED 10ad3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad3f: 57 push %edi <== NOT EXECUTED 10ad40: 56 push %esi <== NOT EXECUTED 10ad41: 53 push %ebx <== NOT EXECUTED 10ad42: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10ad45: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Objects_Locations location; Watchdog_Interval ticks; bool do_wait; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 10ad48: 85 f6 test %esi,%esi <== NOT EXECUTED 10ad4a: 74 78 je 10adc4 <== NOT EXECUTED * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10ad4c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ad4f: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10ad52: 50 push %eax <== NOT EXECUTED 10ad53: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10ad56: e8 b9 62 00 00 call 111014 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 10ad5b: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch (status) { 10ad5d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad60: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10ad63: 76 6f jbe 10add4 <== NOT EXECUTED 10ad65: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10ad68: 75 05 jne 10ad6f <== NOT EXECUTED 10ad6a: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED 10ad6f: 52 push %edx <== NOT EXECUTED 10ad70: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10ad73: 50 push %eax <== NOT EXECUTED 10ad74: ff 36 pushl (%esi) <== NOT EXECUTED 10ad76: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10ad7b: e8 cc 2b 00 00 call 10d94c <_Objects_Get> <== NOT EXECUTED 10ad80: 89 c2 mov %eax,%edx <== NOT EXECUTED do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 10ad82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad85: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10ad88: 85 c0 test %eax,%eax <== NOT EXECUTED 10ad8a: 75 38 jne 10adc4 <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 10ad8c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad8f: 6a 00 push $0x0 <== NOT EXECUTED 10ad91: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10ad94: 89 f9 mov %edi,%ecx <== NOT EXECUTED 10ad96: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 10ad99: 50 push %eax <== NOT EXECUTED 10ad9a: ff 36 pushl (%esi) <== NOT EXECUTED 10ad9c: 8d 42 10 lea 0x10(%edx),%eax <== NOT EXECUTED 10ad9f: 50 push %eax <== NOT EXECUTED 10ada0: e8 ef 20 00 00 call 10ce94 <_CORE_RWLock_Obtain_for_writing> <== NOT EXECUTED do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10ada5: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10ada8: e8 e3 33 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( !do_wait && 10adad: 89 f8 mov %edi,%eax <== NOT EXECUTED 10adaf: 84 c0 test %al,%al <== NOT EXECUTED 10adb1: 75 25 jne 10add8 <== NOT EXECUTED 10adb3: a1 dc 20 12 00 mov 0x1220dc,%eax <== NOT EXECUTED 10adb8: 83 78 34 02 cmpl $0x2,0x34(%eax) <== NOT EXECUTED 10adbc: 75 1f jne 10addd <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 10adbe: 85 db test %ebx,%ebx <== NOT EXECUTED 10adc0: 75 32 jne 10adf4 <== NOT EXECUTED 10adc2: 66 90 xchg %ax,%ax <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: break; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10adc4: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10adc9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10adcc: 5b pop %ebx <== NOT EXECUTED 10adcd: 5e pop %esi <== NOT EXECUTED 10adce: 5f pop %edi <== NOT EXECUTED 10adcf: c9 leave <== NOT EXECUTED 10add0: c3 ret <== NOT EXECUTED 10add1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); switch (status) { 10add4: 31 ff xor %edi,%edi <== NOT EXECUTED 10add6: eb 97 jmp 10ad6f <== NOT EXECUTED 10add8: a1 dc 20 12 00 mov 0x1220dc,%eax <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: break; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10addd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ade0: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10ade3: e8 18 00 00 00 call 10ae00 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 10ade8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10adeb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10adee: 5b pop %ebx <== NOT EXECUTED 10adef: 5e pop %esi <== NOT EXECUTED 10adf0: 5f pop %edi <== NOT EXECUTED 10adf1: c9 leave <== NOT EXECUTED 10adf2: c3 ret <== NOT EXECUTED 10adf3: 90 nop <== NOT EXECUTED ); _Thread_Enable_dispatch(); if ( !do_wait && (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 10adf4: 83 fb 02 cmp $0x2,%ebx <== NOT EXECUTED 10adf7: 77 e4 ja 10addd <== NOT EXECUTED 10adf9: b8 74 00 00 00 mov $0x74,%eax <== NOT EXECUTED 10adfe: eb c9 jmp 10adc9 <== NOT EXECUTED 0010ae10 : */ int pthread_rwlock_tryrdlock( pthread_rwlock_t *rwlock ) { 10ae10: 55 push %ebp <== NOT EXECUTED 10ae11: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae13: 53 push %ebx <== NOT EXECUTED 10ae14: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10ae17: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 10ae1a: 85 db test %ebx,%ebx <== NOT EXECUTED 10ae1c: 74 1b je 10ae39 <== NOT EXECUTED 10ae1e: 51 push %ecx <== NOT EXECUTED 10ae1f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10ae22: 50 push %eax <== NOT EXECUTED 10ae23: ff 33 pushl (%ebx) <== NOT EXECUTED 10ae25: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10ae2a: e8 1d 2b 00 00 call 10d94c <_Objects_Get> <== NOT EXECUTED return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 10ae2f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae32: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10ae35: 85 d2 test %edx,%edx <== NOT EXECUTED 10ae37: 74 0b je 10ae44 <== NOT EXECUTED NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 10ae39: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ae3e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ae41: c9 leave <== NOT EXECUTED 10ae42: c3 ret <== NOT EXECUTED 10ae43: 90 nop <== NOT EXECUTED the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 10ae44: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae47: 6a 00 push $0x0 <== NOT EXECUTED 10ae49: 6a 00 push $0x0 <== NOT EXECUTED 10ae4b: 6a 00 push $0x0 <== NOT EXECUTED 10ae4d: ff 33 pushl (%ebx) <== NOT EXECUTED 10ae4f: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10ae52: 50 push %eax <== NOT EXECUTED 10ae53: e8 74 1f 00 00 call 10cdcc <_CORE_RWLock_Obtain_for_reading> <== NOT EXECUTED 0, NULL ); _Thread_Enable_dispatch(); 10ae58: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10ae5b: e8 30 33 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( 10ae60: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae63: a1 dc 20 12 00 mov 0x1220dc,%eax <== NOT EXECUTED 10ae68: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10ae6b: e8 90 ff ff ff call 10ae00 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 10ae70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ae73: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ae76: c9 leave <== NOT EXECUTED 10ae77: c3 ret <== NOT EXECUTED 0010ae78 : */ int pthread_rwlock_trywrlock( pthread_rwlock_t *rwlock ) { 10ae78: 55 push %ebp <== NOT EXECUTED 10ae79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae7b: 53 push %ebx <== NOT EXECUTED 10ae7c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10ae7f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 10ae82: 85 db test %ebx,%ebx <== NOT EXECUTED 10ae84: 74 1b je 10aea1 <== NOT EXECUTED 10ae86: 51 push %ecx <== NOT EXECUTED 10ae87: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10ae8a: 50 push %eax <== NOT EXECUTED 10ae8b: ff 33 pushl (%ebx) <== NOT EXECUTED 10ae8d: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10ae92: e8 b5 2a 00 00 call 10d94c <_Objects_Get> <== NOT EXECUTED return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 10ae97: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae9a: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10ae9d: 85 d2 test %edx,%edx <== NOT EXECUTED 10ae9f: 74 0b je 10aeac <== NOT EXECUTED 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 10aea1: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10aea6: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10aea9: c9 leave <== NOT EXECUTED 10aeaa: c3 ret <== NOT EXECUTED 10aeab: 90 nop <== NOT EXECUTED the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 10aeac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aeaf: 6a 00 push $0x0 <== NOT EXECUTED 10aeb1: 6a 00 push $0x0 <== NOT EXECUTED 10aeb3: 6a 00 push $0x0 <== NOT EXECUTED 10aeb5: ff 33 pushl (%ebx) <== NOT EXECUTED 10aeb7: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10aeba: 50 push %eax <== NOT EXECUTED 10aebb: e8 d4 1f 00 00 call 10ce94 <_CORE_RWLock_Obtain_for_writing> <== NOT EXECUTED FALSE, /* we are not willing to wait */ 0, NULL ); _Thread_Enable_dispatch(); 10aec0: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10aec3: e8 c8 32 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( 10aec8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aecb: a1 dc 20 12 00 mov 0x1220dc,%eax <== NOT EXECUTED 10aed0: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10aed3: e8 28 ff ff ff call 10ae00 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 10aed8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10aedb: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10aede: c9 leave <== NOT EXECUTED 10aedf: c3 ret <== NOT EXECUTED 0010aee0 : */ int pthread_rwlock_unlock( pthread_rwlock_t *rwlock ) { 10aee0: 55 push %ebp <== NOT EXECUTED 10aee1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aee3: 53 push %ebx <== NOT EXECUTED 10aee4: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10aee7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_RWLock_Control *the_rwlock; Objects_Locations location; CORE_RWLock_Status status; if ( !rwlock ) 10aeea: 85 d2 test %edx,%edx <== NOT EXECUTED 10aeec: 74 1b je 10af09 <== NOT EXECUTED 10aeee: 51 push %ecx <== NOT EXECUTED 10aeef: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10aef2: 50 push %eax <== NOT EXECUTED 10aef3: ff 32 pushl (%edx) <== NOT EXECUTED 10aef5: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10aefa: e8 4d 2a 00 00 call 10d94c <_Objects_Get> <== NOT EXECUTED return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 10aeff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af02: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10af05: 85 d2 test %edx,%edx <== NOT EXECUTED 10af07: 74 0b je 10af14 <== NOT EXECUTED case OBJECTS_LOCAL: status = _CORE_RWLock_Release( &the_rwlock->RWLock ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); 10af09: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10af0e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10af11: c9 leave <== NOT EXECUTED 10af12: c3 ret <== NOT EXECUTED 10af13: 90 nop <== NOT EXECUTED the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { case OBJECTS_LOCAL: status = _CORE_RWLock_Release( &the_rwlock->RWLock ); 10af14: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af17: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10af1a: 50 push %eax <== NOT EXECUTED 10af1b: e8 f4 1f 00 00 call 10cf14 <_CORE_RWLock_Release> <== NOT EXECUTED 10af20: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Enable_dispatch(); 10af22: e8 69 32 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); 10af27: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10af2a: e8 d1 fe ff ff call 10ae00 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 10af2f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10af32: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10af35: c9 leave <== NOT EXECUTED 10af36: c3 ret <== NOT EXECUTED 0010af38 : */ int pthread_rwlock_wrlock( pthread_rwlock_t *rwlock ) { 10af38: 55 push %ebp <== NOT EXECUTED 10af39: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10af3b: 53 push %ebx <== NOT EXECUTED 10af3c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10af3f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 10af42: 85 db test %ebx,%ebx <== NOT EXECUTED 10af44: 74 1b je 10af61 <== NOT EXECUTED 10af46: 51 push %ecx <== NOT EXECUTED 10af47: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10af4a: 50 push %eax <== NOT EXECUTED 10af4b: ff 33 pushl (%ebx) <== NOT EXECUTED 10af4d: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10af52: e8 f5 29 00 00 call 10d94c <_Objects_Get> <== NOT EXECUTED return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 10af57: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af5a: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10af5d: 85 d2 test %edx,%edx <== NOT EXECUTED 10af5f: 74 0b je 10af6c <== NOT EXECUTED 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 10af61: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10af66: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10af69: c9 leave <== NOT EXECUTED 10af6a: c3 ret <== NOT EXECUTED 10af6b: 90 nop <== NOT EXECUTED the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 10af6c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af6f: 6a 00 push $0x0 <== NOT EXECUTED 10af71: 6a 00 push $0x0 <== NOT EXECUTED 10af73: 6a 01 push $0x1 <== NOT EXECUTED 10af75: ff 33 pushl (%ebx) <== NOT EXECUTED 10af77: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10af7a: 50 push %eax <== NOT EXECUTED 10af7b: e8 14 1f 00 00 call 10ce94 <_CORE_RWLock_Obtain_for_writing> <== NOT EXECUTED TRUE, /* do not timeout -- wait forever */ 0, NULL ); _Thread_Enable_dispatch(); 10af80: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10af83: e8 08 32 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( 10af88: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af8b: a1 dc 20 12 00 mov 0x1220dc,%eax <== NOT EXECUTED 10af90: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10af93: e8 68 fe ff ff call 10ae00 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 10af98: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10af9b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10af9e: c9 leave <== NOT EXECUTED 10af9f: c3 ret <== NOT EXECUTED 0010b5e0 : */ int pthread_rwlockattr_destroy( pthread_rwlockattr_t *attr ) { 10b5e0: 55 push %ebp <== NOT EXECUTED 10b5e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b5e3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || attr->is_initialized == FALSE ) 10b5e6: 85 c0 test %eax,%eax <== NOT EXECUTED 10b5e8: 74 12 je 10b5fc <== NOT EXECUTED 10b5ea: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10b5ec: 85 d2 test %edx,%edx <== NOT EXECUTED 10b5ee: 74 0c je 10b5fc <== NOT EXECUTED return EINVAL; attr->is_initialized = FALSE; 10b5f0: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 10b5f6: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10b5f8: c9 leave <== NOT EXECUTED 10b5f9: c3 ret <== NOT EXECUTED 10b5fa: 66 90 xchg %ax,%ax <== NOT EXECUTED { if ( !attr || attr->is_initialized == FALSE ) return EINVAL; attr->is_initialized = FALSE; return 0; 10b5fc: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10b601: c9 leave <== NOT EXECUTED 10b602: c3 ret <== NOT EXECUTED 0010b604 : int pthread_rwlockattr_getpshared( const pthread_rwlockattr_t *attr, int *pshared ) { 10b604: 55 push %ebp <== NOT EXECUTED 10b605: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b607: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr ) 10b60a: 85 c0 test %eax,%eax <== NOT EXECUTED 10b60c: 74 12 je 10b620 <== NOT EXECUTED return EINVAL; if ( !attr->is_initialized ) 10b60e: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10b610: 85 d2 test %edx,%edx <== NOT EXECUTED 10b612: 74 0c je 10b620 <== NOT EXECUTED return EINVAL; *pshared = attr->process_shared; 10b614: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10b617: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10b61a: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10b61c: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10b61e: c9 leave <== NOT EXECUTED 10b61f: c3 ret <== NOT EXECUTED if ( !attr->is_initialized ) return EINVAL; *pshared = attr->process_shared; return 0; 10b620: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10b625: c9 leave <== NOT EXECUTED 10b626: c3 ret <== NOT EXECUTED 0010b628 : */ int pthread_rwlockattr_init( pthread_rwlockattr_t *attr ) { 10b628: 55 push %ebp <== NOT EXECUTED 10b629: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b62b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr ) 10b62e: 85 c0 test %eax,%eax <== NOT EXECUTED 10b630: 74 12 je 10b644 <== NOT EXECUTED return EINVAL; attr->is_initialized = TRUE; 10b632: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED attr->process_shared = PTHREAD_PROCESS_PRIVATE; 10b638: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED 10b63f: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10b641: c9 leave <== NOT EXECUTED 10b642: c3 ret <== NOT EXECUTED 10b643: 90 nop <== NOT EXECUTED int pthread_rwlockattr_init( pthread_rwlockattr_t *attr ) { if ( !attr ) 10b644: b0 16 mov $0x16,%al <== NOT EXECUTED return EINVAL; attr->is_initialized = TRUE; attr->process_shared = PTHREAD_PROCESS_PRIVATE; return 0; } 10b646: c9 leave <== NOT EXECUTED 10b647: c3 ret <== NOT EXECUTED 0010b648 : int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { 10b648: 55 push %ebp <== NOT EXECUTED 10b649: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b64b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr ) 10b64e: 85 c0 test %eax,%eax <== NOT EXECUTED 10b650: 74 0c je 10b65e <== NOT EXECUTED return EINVAL; if ( !attr->is_initialized ) 10b652: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10b654: 85 d2 test %edx,%edx <== NOT EXECUTED 10b656: 74 06 je 10b65e <== NOT EXECUTED return EINVAL; switch ( pshared ) { 10b658: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10b65c: 76 0a jbe 10b668 <== NOT EXECUTED case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; return 0; 10b65e: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10b663: c9 leave <== NOT EXECUTED 10b664: c3 ret <== NOT EXECUTED 10b665: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return EINVAL; switch ( pshared ) { case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10b668: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10b66b: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 10b66e: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; default: return EINVAL; } } 10b670: c9 leave <== NOT EXECUTED 10b671: c3 ret <== NOT EXECUTED 00122050 : #include #include pthread_t pthread_self( void ) { 122050: 55 push %ebp <== NOT EXECUTED 122051: 89 e5 mov %esp,%ebp <== NOT EXECUTED 122053: a1 7c dd 12 00 mov 0x12dd7c,%eax <== NOT EXECUTED 122058: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED return _Thread_Executing->Object.id; } 12205b: c9 leave <== NOT EXECUTED 12205c: c3 ret <== NOT EXECUTED 0010a388 : int pthread_setcancelstate( int state, int *oldstate ) { 10a388: 55 push %ebp <== NOT EXECUTED 10a389: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a38b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 10a38e: a1 b8 22 12 00 mov 0x1222b8,%eax <== NOT EXECUTED 10a393: 85 c0 test %eax,%eax <== NOT EXECUTED 10a395: 75 55 jne 10a3ec <== NOT EXECUTED return EPROTO; if ( !oldstate ) 10a397: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10a39a: 85 d2 test %edx,%edx <== NOT EXECUTED 10a39c: 74 06 je 10a3a4 <== NOT EXECUTED return EINVAL; if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE ) 10a39e: 83 7d 08 01 cmpl $0x1,0x8(%ebp) <== NOT EXECUTED 10a3a2: 76 08 jbe 10a3ac <== NOT EXECUTED if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a3a4: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); return 0; } 10a3a9: c9 leave <== NOT EXECUTED 10a3aa: c3 ret <== NOT EXECUTED 10a3ab: 90 nop <== NOT EXECUTED return EINVAL; if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE ) return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a3ac: a1 dc 22 12 00 mov 0x1222dc,%eax <== NOT EXECUTED 10a3b1: 8b 90 f8 00 00 00 mov 0xf8(%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 10a3b7: a1 18 22 12 00 mov 0x122218,%eax <== NOT EXECUTED 10a3bc: 40 inc %eax <== NOT EXECUTED 10a3bd: a3 18 22 12 00 mov %eax,0x122218 <== NOT EXECUTED _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; 10a3c2: 8b 82 cc 00 00 00 mov 0xcc(%edx),%eax <== NOT EXECUTED 10a3c8: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10a3cb: 89 01 mov %eax,(%ecx) <== NOT EXECUTED thread_support->cancelability_state = state; 10a3cd: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a3d0: 89 82 cc 00 00 00 mov %eax,0xcc(%edx) <== NOT EXECUTED if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10a3d6: 85 c0 test %eax,%eax <== NOT EXECUTED 10a3d8: 75 09 jne 10a3e3 <== NOT EXECUTED 10a3da: 83 ba d0 00 00 00 01 cmpl $0x1,0xd0(%edx) <== NOT EXECUTED 10a3e1: 74 11 je 10a3f4 <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a3e3: e8 84 29 00 00 call 10cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a3e8: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); return 0; } 10a3ea: c9 leave <== NOT EXECUTED 10a3eb: c3 ret <== NOT EXECUTED * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 10a3ec: b8 47 00 00 00 mov $0x47,%eax <== NOT EXECUTED _Thread_Enable_dispatch(); if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); return 0; } 10a3f1: c9 leave <== NOT EXECUTED 10a3f2: c3 ret <== NOT EXECUTED 10a3f3: 90 nop <== NOT EXECUTED _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; thread_support->cancelability_state = state; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10a3f4: 8b 82 d4 00 00 00 mov 0xd4(%edx),%eax <== NOT EXECUTED 10a3fa: 85 c0 test %eax,%eax <== NOT EXECUTED 10a3fc: 74 e5 je 10a3e3 <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a3fe: e8 69 29 00 00 call 10cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10a403: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a406: 6a ff push $0xffffffff <== NOT EXECUTED 10a408: ff 35 dc 22 12 00 pushl 0x1222dc <== NOT EXECUTED 10a40e: e8 55 fb ff ff call 109f68 <_POSIX_Thread_Exit> <== NOT EXECUTED 10a413: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a415: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10a418: c9 leave <== NOT EXECUTED 10a419: c3 ret <== NOT EXECUTED 0010a41c : int pthread_setcanceltype( int type, int *oldtype ) { 10a41c: 55 push %ebp <== NOT EXECUTED 10a41d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a41f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 10a422: a1 b8 22 12 00 mov 0x1222b8,%eax <== NOT EXECUTED 10a427: 85 c0 test %eax,%eax <== NOT EXECUTED 10a429: 75 55 jne 10a480 <== NOT EXECUTED return EPROTO; if ( !oldtype ) 10a42b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a42e: 85 c0 test %eax,%eax <== NOT EXECUTED 10a430: 74 06 je 10a438 <== NOT EXECUTED return EINVAL; if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS ) 10a432: 83 7d 08 01 cmpl $0x1,0x8(%ebp) <== NOT EXECUTED 10a436: 76 08 jbe 10a440 <== NOT EXECUTED if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a438: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); return 0; } 10a43d: c9 leave <== NOT EXECUTED 10a43e: c3 ret <== NOT EXECUTED 10a43f: 90 nop <== NOT EXECUTED return EINVAL; if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS ) return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a440: a1 dc 22 12 00 mov 0x1222dc,%eax <== NOT EXECUTED 10a445: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx <== NOT EXECUTED 10a44b: a1 18 22 12 00 mov 0x122218,%eax <== NOT EXECUTED 10a450: 40 inc %eax <== NOT EXECUTED 10a451: a3 18 22 12 00 mov %eax,0x122218 <== NOT EXECUTED _Thread_Disable_dispatch(); *oldtype = thread_support->cancelability_type; 10a456: 8b 82 d0 00 00 00 mov 0xd0(%edx),%eax <== NOT EXECUTED 10a45c: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10a45f: 89 01 mov %eax,(%ecx) <== NOT EXECUTED thread_support->cancelability_type = type; 10a461: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a464: 89 82 d0 00 00 00 mov %eax,0xd0(%edx) <== NOT EXECUTED if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10a46a: 8b 8a cc 00 00 00 mov 0xcc(%edx),%ecx <== NOT EXECUTED 10a470: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a472: 75 03 jne 10a477 <== NOT EXECUTED 10a474: 48 dec %eax <== NOT EXECUTED 10a475: 74 11 je 10a488 <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a477: e8 f0 28 00 00 call 10cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a47c: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); return 0; } 10a47e: c9 leave <== NOT EXECUTED 10a47f: c3 ret <== NOT EXECUTED * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 10a480: b8 47 00 00 00 mov $0x47,%eax <== NOT EXECUTED _Thread_Enable_dispatch(); if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); return 0; } 10a485: c9 leave <== NOT EXECUTED 10a486: c3 ret <== NOT EXECUTED 10a487: 90 nop <== NOT EXECUTED _Thread_Disable_dispatch(); *oldtype = thread_support->cancelability_type; thread_support->cancelability_type = type; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10a488: 8b 82 d4 00 00 00 mov 0xd4(%edx),%eax <== NOT EXECUTED 10a48e: 85 c0 test %eax,%eax <== NOT EXECUTED 10a490: 74 e5 je 10a477 <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a492: e8 d5 28 00 00 call 10cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10a497: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a49a: 6a ff push $0xffffffff <== NOT EXECUTED 10a49c: ff 35 dc 22 12 00 pushl 0x1222dc <== NOT EXECUTED 10a4a2: e8 c1 fa ff ff call 109f68 <_POSIX_Thread_Exit> <== NOT EXECUTED 10a4a7: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a4a9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10a4ac: c9 leave <== NOT EXECUTED 10a4ad: c3 ret <== NOT EXECUTED 0010c938 : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 10c938: 55 push %ebp <== NOT EXECUTED 10c939: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c93b: 57 push %edi <== NOT EXECUTED 10c93c: 56 push %esi <== NOT EXECUTED 10c93d: 53 push %ebx <== NOT EXECUTED 10c93e: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED /* * Check all the parameters */ if ( !param ) 10c941: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10c944: 85 c0 test %eax,%eax <== NOT EXECUTED 10c946: 74 29 je 10c971 <== NOT EXECUTED return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 10c948: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10c94b: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10c94d: 48 dec %eax <== NOT EXECUTED 10c94e: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10c953: 77 1c ja 10c971 <== NOT EXECUTED return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 10c955: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10c959: 74 25 je 10c980 <== NOT EXECUTED 10c95b: 0f 8e 33 01 00 00 jle 10ca94 <== NOT EXECUTED 10c961: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) <== NOT EXECUTED 10c965: 0f 84 15 01 00 00 je 10ca80 <== NOT EXECUTED 10c96b: 83 7d 0c 03 cmpl $0x3,0xc(%ebp) <== NOT EXECUTED 10c96f: 74 4b je 10c9bc <== NOT EXECUTED _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); break; } _Thread_Enable_dispatch(); return 0; 10c971: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10c976: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c979: 5b pop %ebx <== NOT EXECUTED 10c97a: 5e pop %esi <== NOT EXECUTED 10c97b: 5f pop %edi <== NOT EXECUTED 10c97c: c9 leave <== NOT EXECUTED 10c97d: c3 ret <== NOT EXECUTED 10c97e: 66 90 xchg %ax,%ax <== NOT EXECUTED return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 10c980: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED 10c987: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10c98e: 50 push %eax <== NOT EXECUTED 10c98f: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10c992: 50 push %eax <== NOT EXECUTED 10c993: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c996: 68 60 54 12 00 push $0x125460 <== NOT EXECUTED 10c99b: e8 70 21 00 00 call 10eb10 <_Objects_Get> <== NOT EXECUTED 10c9a0: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 10c9a3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c9a6: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 10c9a9: 85 ff test %edi,%edi <== NOT EXECUTED 10c9ab: 74 53 je 10ca00 <== NOT EXECUTED 10c9ad: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10c9b2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c9b5: 5b pop %ebx <== NOT EXECUTED 10c9b6: 5e pop %esi <== NOT EXECUTED 10c9b7: 5f pop %edi <== NOT EXECUTED 10c9b8: c9 leave <== NOT EXECUTED 10c9b9: c3 ret <== NOT EXECUTED 10c9ba: 66 90 xchg %ax,%ax <== NOT EXECUTED case SCHED_SPORADIC: budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; budget_callout = _POSIX_Threads_Sporadic_budget_callout; if ( _Timespec_To_ticks( ¶m->ss_replenish_period ) < 10c9bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c9bf: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10c9c2: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 10c9c5: 50 push %eax <== NOT EXECUTED 10c9c6: e8 79 36 00 00 call 110044 <_Timespec_To_ticks> <== NOT EXECUTED 10c9cb: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10c9cd: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10c9d0: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10c9d3: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10c9d6: e8 69 36 00 00 call 110044 <_Timespec_To_ticks> <== NOT EXECUTED 10c9db: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c9de: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10c9e0: 72 8f jb 10c971 <== NOT EXECUTED _Timespec_To_ticks( ¶m->ss_initial_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( param->ss_low_priority ) ) 10c9e2: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10c9e5: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10c9e8: 48 dec %eax <== NOT EXECUTED 10c9e9: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10c9ee: 77 81 ja 10c971 <== NOT EXECUTED 10c9f0: c7 45 dc 03 00 00 00 movl $0x3,-0x24(%ebp) <== NOT EXECUTED 10c9f7: c7 45 e0 5c c8 10 00 movl $0x10c85c,-0x20(%ebp) <== NOT EXECUTED 10c9fe: eb 8e jmp 10c98e <== NOT EXECUTED the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10ca00: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10ca03: 8b 98 f8 00 00 00 mov 0xf8(%eax),%ebx <== NOT EXECUTED if ( api->schedpolicy == SCHED_SPORADIC ) 10ca09: 83 7b 7c 03 cmpl $0x3,0x7c(%ebx) <== NOT EXECUTED 10ca0d: 0f 84 d5 00 00 00 je 10cae8 <== NOT EXECUTED (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; 10ca13: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10ca16: 89 53 7c mov %edx,0x7c(%ebx) <== NOT EXECUTED api->schedparam = *param; 10ca19: 8d bb 80 00 00 00 lea 0x80(%ebx),%edi <== NOT EXECUTED 10ca1f: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10ca24: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10ca27: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED the_thread->budget_algorithm = budget_algorithm; 10ca29: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 10ca2c: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10ca2f: 89 50 7c mov %edx,0x7c(%eax) <== NOT EXECUTED the_thread->budget_callout = budget_callout; 10ca32: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED 10ca35: 89 b0 80 00 00 00 mov %esi,0x80(%eax) <== NOT EXECUTED switch ( api->schedpolicy ) { 10ca3b: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10ca3e: 85 f6 test %esi,%esi <== NOT EXECUTED 10ca40: 78 2c js 10ca6e <== NOT EXECUTED 10ca42: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) <== NOT EXECUTED 10ca46: 7f 6c jg 10cab4 <== NOT EXECUTED case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10ca48: a1 64 51 12 00 mov 0x125164,%eax <== NOT EXECUTED 10ca4d: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 10ca50: 89 42 78 mov %eax,0x78(%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 10ca53: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10ca58: 2b 83 80 00 00 00 sub 0x80(%ebx),%eax <== NOT EXECUTED the_thread->real_priority = 10ca5e: 89 42 18 mov %eax,0x18(%edx) <== NOT EXECUTED _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 10ca61: 51 push %ecx <== NOT EXECUTED 10ca62: 6a 01 push $0x1 <== NOT EXECUTED 10ca64: 50 push %eax <== NOT EXECUTED 10ca65: 52 push %edx <== NOT EXECUTED 10ca66: e8 0d 24 00 00 call 10ee78 <_Thread_Change_priority> <== NOT EXECUTED 10ca6b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Watchdog_Remove( &api->Sporadic_timer ); _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); break; } _Thread_Enable_dispatch(); 10ca6e: e8 e1 28 00 00 call 10f354 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ca73: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10ca75: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ca78: 5b pop %ebx <== NOT EXECUTED 10ca79: 5e pop %esi <== NOT EXECUTED 10ca7a: 5f pop %edi <== NOT EXECUTED 10ca7b: c9 leave <== NOT EXECUTED 10ca7c: c3 ret <== NOT EXECUTED 10ca7d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 10ca80: c7 45 dc 02 00 00 00 movl $0x2,-0x24(%ebp) <== NOT EXECUTED 10ca87: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 10ca8e: e9 fb fe ff ff jmp 10c98e <== NOT EXECUTED 10ca93: 90 nop <== NOT EXECUTED 10ca94: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ca97: 85 c0 test %eax,%eax <== NOT EXECUTED 10ca99: 0f 85 d2 fe ff ff jne 10c971 <== NOT EXECUTED 10ca9f: c7 45 dc 01 00 00 00 movl $0x1,-0x24(%ebp) <== NOT EXECUTED 10caa6: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 10caad: e9 dc fe ff ff jmp 10c98e <== NOT EXECUTED 10cab2: 66 90 xchg %ax,%ax <== NOT EXECUTED api->schedpolicy = policy; api->schedparam = *param; the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 10cab4: 83 7d 0c 03 cmpl $0x3,0xc(%ebp) <== NOT EXECUTED 10cab8: 75 b4 jne 10ca6e <== NOT EXECUTED TRUE ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 10caba: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax <== NOT EXECUTED 10cac0: 89 83 98 00 00 00 mov %eax,0x98(%ebx) <== NOT EXECUTED _Watchdog_Remove( &api->Sporadic_timer ); 10cac6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cac9: 8d 83 9c 00 00 00 lea 0x9c(%ebx),%eax <== NOT EXECUTED 10cacf: 50 push %eax <== NOT EXECUTED 10cad0: e8 27 3a 00 00 call 1104fc <_Watchdog_Remove> <== NOT EXECUTED _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 10cad5: 58 pop %eax <== NOT EXECUTED 10cad6: 5a pop %edx <== NOT EXECUTED 10cad7: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 10cada: 6a 00 push $0x0 <== NOT EXECUTED 10cadc: e8 bb fd ff ff call 10c89c <_POSIX_Threads_Sporadic_budget_TSR> <== NOT EXECUTED 10cae1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cae4: eb 88 jmp 10ca6e <== NOT EXECUTED 10cae6: 66 90 xchg %ax,%ax <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); 10cae8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10caeb: 8d 83 9c 00 00 00 lea 0x9c(%ebx),%eax <== NOT EXECUTED 10caf1: 50 push %eax <== NOT EXECUTED 10caf2: e8 05 3a 00 00 call 1104fc <_Watchdog_Remove> <== NOT EXECUTED 10caf7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cafa: e9 14 ff ff ff jmp 10ca13 <== NOT EXECUTED 0010a2c8 : int pthread_setspecific( pthread_key_t key, const void *value ) { 10a2c8: 55 push %ebp <== NOT EXECUTED 10a2c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a2cb: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10a2ce: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10a2d1: 50 push %eax <== NOT EXECUTED 10a2d2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a2d5: 68 40 27 12 00 push $0x122740 <== NOT EXECUTED 10a2da: e8 91 27 00 00 call 10ca70 <_Objects_Get> <== NOT EXECUTED 10a2df: 89 c1 mov %eax,%ecx <== NOT EXECUTED uint32_t api; uint32_t index; Objects_Locations location; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 10a2e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a2e4: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED 10a2e7: 85 c0 test %eax,%eax <== NOT EXECUTED 10a2e9: 75 29 jne 10a314 <== NOT EXECUTED case OBJECTS_LOCAL: api = _Objects_Get_API( _Thread_Executing->Object.id ); 10a2eb: a1 5c 23 12 00 mov 0x12235c,%eax <== NOT EXECUTED 10a2f0: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED index = _Objects_Get_index( _Thread_Executing->Object.id ); the_key->Values[ api ][ index ] = (void *) value; 10a2f3: 89 d0 mov %edx,%eax <== NOT EXECUTED 10a2f5: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10a2f8: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 10a2fb: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10a301: 8b 44 81 18 mov 0x18(%ecx,%eax,4),%eax <== NOT EXECUTED 10a305: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10a308: 89 0c 90 mov %ecx,(%eax,%edx,4) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a30b: e8 a4 2f 00 00 call 10d2b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a310: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a312: c9 leave <== NOT EXECUTED 10a313: c3 ret <== NOT EXECUTED uint32_t api; uint32_t index; Objects_Locations location; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 10a314: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a319: c9 leave <== NOT EXECUTED 10a31a: c3 ret <== NOT EXECUTED 00110444 : int pthread_sigmask( int how, const sigset_t *set, sigset_t *oset ) { 110444: 55 push %ebp <== NOT EXECUTED 110445: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110447: 57 push %edi <== NOT EXECUTED 110448: 56 push %esi <== NOT EXECUTED 110449: 53 push %ebx <== NOT EXECUTED 11044a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11044d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 110450: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 110453: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED POSIX_API_Control *api; if ( !set && !oset ) 110456: 85 f6 test %esi,%esi <== NOT EXECUTED 110458: 0f 84 8e 00 00 00 je 1104ec <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 11045e: 8b 3d 1c 24 12 00 mov 0x12241c,%edi <== NOT EXECUTED 110464: 8b 8f f8 00 00 00 mov 0xf8(%edi),%ecx <== NOT EXECUTED if ( oset ) 11046a: 85 d2 test %edx,%edx <== NOT EXECUTED 11046c: 74 08 je 110476 <== NOT EXECUTED *oset = api->signals_blocked; 11046e: 8b 81 c4 00 00 00 mov 0xc4(%ecx),%eax <== NOT EXECUTED 110474: 89 02 mov %eax,(%edx) <== NOT EXECUTED if ( !set ) return 0; switch ( how ) { 110476: 83 fb 01 cmp $0x1,%ebx <== NOT EXECUTED 110479: 74 65 je 1104e0 <== NOT EXECUTED 11047b: 83 fb 02 cmp $0x2,%ebx <== NOT EXECUTED 11047e: 74 3c je 1104bc <== NOT EXECUTED 110480: 85 db test %ebx,%ebx <== NOT EXECUTED 110482: 75 44 jne 1104c8 <== NOT EXECUTED break; case SIG_UNBLOCK: api->signals_blocked &= ~*set; break; case SIG_SETMASK: api->signals_blocked = *set; 110484: 8b 06 mov (%esi),%eax <== NOT EXECUTED 110486: 89 81 c4 00 00 00 mov %eax,0xc4(%ecx) <== NOT EXECUTED /* XXX are there critical section problems here? */ /* XXX evaluate the new set */ if ( ~api->signals_blocked & 11048c: 8b 15 80 2b 12 00 mov 0x122b80,%edx <== NOT EXECUTED 110492: 0b 91 c8 00 00 00 or 0xc8(%ecx),%edx <== NOT EXECUTED 110498: 8b 81 c4 00 00 00 mov 0xc4(%ecx),%eax <== NOT EXECUTED 11049e: f7 d0 not %eax <== NOT EXECUTED 1104a0: 85 c2 test %eax,%edx <== NOT EXECUTED 1104a2: 75 0c jne 1104b0 <== NOT EXECUTED (api->signals_pending | _POSIX_signals_Pending) ) { _Thread_Executing->do_post_task_switch_extension = true; _Thread_Dispatch(); 1104a4: 31 c0 xor %eax,%eax <== NOT EXECUTED } return 0; } 1104a6: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1104a9: 5b pop %ebx <== NOT EXECUTED 1104aa: 5e pop %esi <== NOT EXECUTED 1104ab: 5f pop %edi <== NOT EXECUTED 1104ac: c9 leave <== NOT EXECUTED 1104ad: c3 ret <== NOT EXECUTED 1104ae: 66 90 xchg %ax,%ax <== NOT EXECUTED /* XXX evaluate the new set */ if ( ~api->signals_blocked & (api->signals_pending | _POSIX_signals_Pending) ) { _Thread_Executing->do_post_task_switch_extension = true; 1104b0: c6 47 75 01 movb $0x1,0x75(%edi) <== NOT EXECUTED _Thread_Dispatch(); 1104b4: e8 87 cd ff ff call 10d240 <_Thread_Dispatch> <== NOT EXECUTED 1104b9: eb e9 jmp 1104a4 <== NOT EXECUTED 1104bb: 90 nop <== NOT EXECUTED switch ( how ) { case SIG_BLOCK: api->signals_blocked |= *set; break; case SIG_UNBLOCK: api->signals_blocked &= ~*set; 1104bc: 8b 06 mov (%esi),%eax <== NOT EXECUTED 1104be: f7 d0 not %eax <== NOT EXECUTED 1104c0: 21 81 c4 00 00 00 and %eax,0xc4(%ecx) <== NOT EXECUTED 1104c6: eb c4 jmp 11048c <== NOT EXECUTED break; case SIG_SETMASK: api->signals_blocked = *set; break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 1104c8: e8 ff 17 00 00 call 111ccc <__errno> <== NOT EXECUTED 1104cd: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1104d3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED _Thread_Executing->do_post_task_switch_extension = true; _Thread_Dispatch(); } return 0; } 1104d8: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1104db: 5b pop %ebx <== NOT EXECUTED 1104dc: 5e pop %esi <== NOT EXECUTED 1104dd: 5f pop %edi <== NOT EXECUTED 1104de: c9 leave <== NOT EXECUTED 1104df: c3 ret <== NOT EXECUTED if ( !set ) return 0; switch ( how ) { case SIG_BLOCK: api->signals_blocked |= *set; 1104e0: 8b 06 mov (%esi),%eax <== NOT EXECUTED 1104e2: 09 81 c4 00 00 00 or %eax,0xc4(%ecx) <== NOT EXECUTED 1104e8: eb a2 jmp 11048c <== NOT EXECUTED 1104ea: 66 90 xchg %ax,%ax <== NOT EXECUTED sigset_t *oset ) { POSIX_API_Control *api; if ( !set && !oset ) 1104ec: 85 d2 test %edx,%edx <== NOT EXECUTED 1104ee: 74 d8 je 1104c8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; if ( oset ) *oset = api->signals_blocked; 1104f0: a1 1c 24 12 00 mov 0x12241c,%eax <== NOT EXECUTED 1104f5: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax <== NOT EXECUTED 1104fb: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED 110501: 89 02 mov %eax,(%edx) <== NOT EXECUTED 110503: 31 c0 xor %eax,%eax <== NOT EXECUTED _Thread_Executing->do_post_task_switch_extension = true; _Thread_Dispatch(); } return 0; } 110505: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 110508: 5b pop %ebx <== NOT EXECUTED 110509: 5e pop %esi <== NOT EXECUTED 11050a: 5f pop %edi <== NOT EXECUTED 11050b: c9 leave <== NOT EXECUTED 11050c: c3 ret <== NOT EXECUTED 0010a1ec : */ int pthread_spin_destroy( pthread_spinlock_t *spinlock ) { 10a1ec: 55 push %ebp <== NOT EXECUTED 10a1ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a1ef: 53 push %ebx <== NOT EXECUTED 10a1f0: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10a1f3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; if ( !spinlock ) 10a1f6: 85 d2 test %edx,%edx <== NOT EXECUTED 10a1f8: 74 36 je 10a230 <== 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 10a1fa: 53 push %ebx <== NOT EXECUTED 10a1fb: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a1fe: 50 push %eax <== NOT EXECUTED 10a1ff: ff 32 pushl (%edx) <== NOT EXECUTED 10a201: 68 c0 0b 12 00 push $0x120bc0 <== NOT EXECUTED 10a206: e8 61 23 00 00 call 10c56c <_Objects_Get> <== NOT EXECUTED 10a20b: 89 c3 mov %eax,%ebx <== NOT EXECUTED return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 10a20d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a210: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 10a213: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a215: 75 19 jne 10a230 <== 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. * 10a217: 8b 40 18 mov 0x18(%eax),%eax <== NOT EXECUTED case OBJECTS_LOCAL: if ( _CORE_spinlock_Is_busy( &the_spinlock->Spinlock ) ) { 10a21a: 85 c0 test %eax,%eax <== NOT EXECUTED 10a21c: 74 1e je 10a23c <== NOT EXECUTED _Thread_Enable_dispatch(); 10a21e: e8 8d 2b 00 00 call 10cdb0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a223: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a228: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a22b: c9 leave <== NOT EXECUTED 10a22c: c3 ret <== NOT EXECUTED 10a22d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Objects_Close( &_POSIX_Spinlock_Information, &the_spinlock->Object ); _POSIX_Spinlock_Free( the_spinlock ); _Thread_Enable_dispatch(); return 0; 10a230: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a235: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a238: c9 leave <== NOT EXECUTED 10a239: c3 ret <== NOT EXECUTED 10a23a: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( _CORE_spinlock_Is_busy( &the_spinlock->Spinlock ) ) { _Thread_Enable_dispatch(); return EBUSY; } _Objects_Close( &_POSIX_Spinlock_Information, &the_spinlock->Object ); 10a23c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a23f: 53 push %ebx <== NOT EXECUTED 10a240: 68 c0 0b 12 00 push $0x120bc0 <== NOT EXECUTED 10a245: e8 ae 1e 00 00 call 10c0f8 <_Objects_Close> <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon * @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 * 10a24a: 58 pop %eax <== NOT EXECUTED 10a24b: 5a pop %edx <== NOT EXECUTED 10a24c: 53 push %ebx <== NOT EXECUTED 10a24d: 68 c0 0b 12 00 push $0x120bc0 <== NOT EXECUTED 10a252: e8 e1 21 00 00 call 10c438 <_Objects_Free> <== NOT EXECUTED _POSIX_Spinlock_Free( the_spinlock ); _Thread_Enable_dispatch(); 10a257: e8 54 2b 00 00 call 10cdb0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a25c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a25e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a261: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a264: c9 leave <== NOT EXECUTED 10a265: c3 ret <== NOT EXECUTED 0010a268 : int pthread_spin_init( pthread_spinlock_t *spinlock, int pshared ) { 10a268: 55 push %ebp <== NOT EXECUTED 10a269: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a26b: 56 push %esi <== NOT EXECUTED 10a26c: 53 push %ebx <== NOT EXECUTED 10a26d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10a270: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED POSIX_Spinlock_Control *the_spinlock; CORE_spinlock_Attributes attributes; if ( !spinlock ) 10a273: 85 f6 test %esi,%esi <== NOT EXECUTED 10a275: 74 61 je 10a2d8 <== NOT EXECUTED return EINVAL; switch ( pshared ) { 10a277: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a27a: 85 c0 test %eax,%eax <== NOT EXECUTED 10a27c: 75 5a jne 10a2d8 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a27e: a1 b8 08 12 00 mov 0x1208b8,%eax <== NOT EXECUTED 10a283: 40 inc %eax <== NOT EXECUTED 10a284: a3 b8 08 12 00 mov %eax,0x1208b8 <== NOT EXECUTED */ /**@{*/ #ifdef __cplusplus extern "C" { #endif 10a289: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a28c: 68 c0 0b 12 00 push $0x120bc0 <== NOT EXECUTED 10a291: e8 e2 1d 00 00 call 10c078 <_Objects_Allocate> <== NOT EXECUTED 10a296: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_spinlock = _POSIX_Spinlock_Allocate(); if ( !the_spinlock ) { 10a298: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a29b: 85 c0 test %eax,%eax <== NOT EXECUTED 10a29d: 74 45 je 10a2e4 <== NOT EXECUTED _Thread_Enable_dispatch(); return EAGAIN; } _CORE_spinlock_Initialize( &the_spinlock->Spinlock, &attributes ); 10a29f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a2a2: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10a2a5: 50 push %eax <== NOT EXECUTED 10a2a6: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10a2a9: 50 push %eax <== NOT EXECUTED 10a2aa: e8 11 19 00 00 call 10bbc0 <_CORE_spinlock_Initialize> <== NOT EXECUTED 10a2af: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10a2b2: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10a2b5: a1 dc 0b 12 00 mov 0x120bdc,%eax <== NOT EXECUTED 10a2ba: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10a2bd: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED _Objects_Open_u32( &_POSIX_Spinlock_Information, &the_spinlock->Object, 0 ); *spinlock = the_spinlock->Object.id; 10a2c4: 89 0e mov %ecx,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a2c6: e8 e5 2a 00 00 call 10cdb0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a2cb: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a2cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10a2d0: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a2d3: 5b pop %ebx <== NOT EXECUTED 10a2d4: 5e pop %esi <== NOT EXECUTED 10a2d5: c9 leave <== NOT EXECUTED 10a2d6: c3 ret <== NOT EXECUTED 10a2d7: 90 nop <== NOT EXECUTED _Objects_Open_u32( &_POSIX_Spinlock_Information, &the_spinlock->Object, 0 ); *spinlock = the_spinlock->Object.id; _Thread_Enable_dispatch(); return 0; 10a2d8: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10a2dd: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a2e0: 5b pop %ebx <== NOT EXECUTED 10a2e1: 5e pop %esi <== NOT EXECUTED 10a2e2: c9 leave <== NOT EXECUTED 10a2e3: c3 ret <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_spinlock = _POSIX_Spinlock_Allocate(); if ( !the_spinlock ) { _Thread_Enable_dispatch(); 10a2e4: e8 c7 2a 00 00 call 10cdb0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a2e9: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 10a2ee: eb ed jmp 10a2dd <== NOT EXECUTED 0010a2f0 : */ int pthread_spin_lock( pthread_spinlock_t *spinlock ) { 10a2f0: 55 push %ebp <== NOT EXECUTED 10a2f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a2f3: 53 push %ebx <== NOT EXECUTED 10a2f4: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10a2f7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 10a2fa: 85 d2 test %edx,%edx <== NOT EXECUTED 10a2fc: 74 1b je 10a319 <== 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 10a2fe: 53 push %ebx <== NOT EXECUTED 10a2ff: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a302: 50 push %eax <== NOT EXECUTED 10a303: ff 32 pushl (%edx) <== NOT EXECUTED 10a305: 68 c0 0b 12 00 push $0x120bc0 <== NOT EXECUTED 10a30a: e8 5d 22 00 00 call 10c56c <_Objects_Get> <== NOT EXECUTED return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 10a30f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a312: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 10a315: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a317: 74 0b je 10a324 <== NOT EXECUTED case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, TRUE, 0 ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 10a319: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a31e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a321: c9 leave <== NOT EXECUTED 10a322: c3 ret <== NOT EXECUTED 10a323: 90 nop <== NOT EXECUTED the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, TRUE, 0 ); 10a324: 52 push %edx <== NOT EXECUTED 10a325: 6a 00 push $0x0 <== NOT EXECUTED 10a327: 6a 01 push $0x1 <== NOT EXECUTED 10a329: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10a32c: 50 push %eax <== NOT EXECUTED 10a32d: e8 fe 18 00 00 call 10bc30 <_CORE_spinlock_Wait> <== NOT EXECUTED 10a332: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Enable_dispatch(); 10a334: e8 77 2a 00 00 call 10cdb0 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 10a339: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a33c: e8 0b 00 00 00 call 10a34c <_POSIX_Spinlock_Translate_core_spinlock_return_code> <== NOT EXECUTED 10a341: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a344: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a347: c9 leave <== NOT EXECUTED 10a348: c3 ret <== NOT EXECUTED 0010a35c : */ int pthread_spin_trylock( pthread_spinlock_t *spinlock ) { 10a35c: 55 push %ebp <== NOT EXECUTED 10a35d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a35f: 53 push %ebx <== NOT EXECUTED 10a360: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10a363: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 10a366: 85 d2 test %edx,%edx <== NOT EXECUTED 10a368: 74 1b je 10a385 <== NOT EXECUTED 10a36a: 53 push %ebx <== NOT EXECUTED 10a36b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a36e: 50 push %eax <== NOT EXECUTED 10a36f: ff 32 pushl (%edx) <== NOT EXECUTED 10a371: 68 c0 0b 12 00 push $0x120bc0 <== NOT EXECUTED 10a376: e8 f1 21 00 00 call 10c56c <_Objects_Get> <== NOT EXECUTED return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 10a37b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a37e: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 10a381: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a383: 74 0b je 10a390 <== NOT EXECUTED case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, FALSE, 0 ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 10a385: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a38a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a38d: c9 leave <== NOT EXECUTED 10a38e: c3 ret <== NOT EXECUTED 10a38f: 90 nop <== NOT EXECUTED the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, FALSE, 0 ); 10a390: 52 push %edx <== NOT EXECUTED 10a391: 6a 00 push $0x0 <== NOT EXECUTED 10a393: 6a 00 push $0x0 <== NOT EXECUTED 10a395: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10a398: 50 push %eax <== NOT EXECUTED 10a399: e8 92 18 00 00 call 10bc30 <_CORE_spinlock_Wait> <== NOT EXECUTED 10a39e: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Enable_dispatch(); 10a3a0: e8 0b 2a 00 00 call 10cdb0 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 10a3a5: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a3a8: e8 9f ff ff ff call 10a34c <_POSIX_Spinlock_Translate_core_spinlock_return_code> <== NOT EXECUTED 10a3ad: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a3b0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a3b3: c9 leave <== NOT EXECUTED 10a3b4: c3 ret <== NOT EXECUTED 0010a3b8 : */ int pthread_spin_unlock( pthread_spinlock_t *spinlock ) { 10a3b8: 55 push %ebp <== NOT EXECUTED 10a3b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a3bb: 53 push %ebx <== NOT EXECUTED 10a3bc: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10a3bf: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 10a3c2: 85 d2 test %edx,%edx <== NOT EXECUTED 10a3c4: 74 1b je 10a3e1 <== NOT EXECUTED 10a3c6: 51 push %ecx <== NOT EXECUTED 10a3c7: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a3ca: 50 push %eax <== NOT EXECUTED 10a3cb: ff 32 pushl (%edx) <== NOT EXECUTED 10a3cd: 68 c0 0b 12 00 push $0x120bc0 <== NOT EXECUTED 10a3d2: e8 95 21 00 00 call 10c56c <_Objects_Get> <== NOT EXECUTED return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 10a3d7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a3da: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10a3dd: 85 d2 test %edx,%edx <== NOT EXECUTED 10a3df: 74 0b je 10a3ec <== NOT EXECUTED case OBJECTS_LOCAL: status = _CORE_spinlock_Release( &the_spinlock->Spinlock ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 10a3e1: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a3e6: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a3e9: c9 leave <== NOT EXECUTED 10a3ea: c3 ret <== NOT EXECUTED 10a3eb: 90 nop <== NOT EXECUTED the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { case OBJECTS_LOCAL: status = _CORE_spinlock_Release( &the_spinlock->Spinlock ); 10a3ec: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a3ef: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10a3f2: 50 push %eax <== NOT EXECUTED 10a3f3: e8 ec 17 00 00 call 10bbe4 <_CORE_spinlock_Release> <== NOT EXECUTED 10a3f8: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Enable_dispatch(); 10a3fa: e8 b1 29 00 00 call 10cdb0 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 10a3ff: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a402: e8 45 ff ff ff call 10a34c <_POSIX_Spinlock_Translate_core_spinlock_return_code> <== NOT EXECUTED 10a407: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a40a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a40d: c9 leave <== NOT EXECUTED 10a40e: c3 ret <== NOT EXECUTED 0010a4d8 : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 10a4d8: 55 push %ebp <== NOT EXECUTED 10a4d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4db: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 10a4de: a1 b8 22 12 00 mov 0x1222b8,%eax <== NOT EXECUTED 10a4e3: 85 c0 test %eax,%eax <== NOT EXECUTED 10a4e5: 75 42 jne 10a529 <== NOT EXECUTED return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a4e7: a1 dc 22 12 00 mov 0x1222dc,%eax <== NOT EXECUTED 10a4ec: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx <== NOT EXECUTED 10a4f2: a1 18 22 12 00 mov 0x122218,%eax <== NOT EXECUTED 10a4f7: 40 inc %eax <== NOT EXECUTED 10a4f8: a3 18 22 12 00 mov %eax,0x122218 <== NOT EXECUTED _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10a4fd: 8b 8a cc 00 00 00 mov 0xcc(%edx),%ecx <== NOT EXECUTED 10a503: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a505: 75 25 jne 10a52c <== NOT EXECUTED 10a507: 8b 82 d4 00 00 00 mov 0xd4(%edx),%eax <== NOT EXECUTED 10a50d: 85 c0 test %eax,%eax <== NOT EXECUTED 10a50f: 74 1b je 10a52c <== NOT EXECUTED thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a511: e8 56 28 00 00 call 10cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10a516: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a519: 6a ff push $0xffffffff <== NOT EXECUTED 10a51b: ff 35 dc 22 12 00 pushl 0x1222dc <== NOT EXECUTED 10a521: e8 42 fa ff ff call 109f68 <_POSIX_Thread_Exit> <== NOT EXECUTED 10a526: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10a529: c9 leave <== NOT EXECUTED 10a52a: c3 ret <== NOT EXECUTED 10a52b: 90 nop <== NOT EXECUTED 10a52c: c9 leave <== NOT EXECUTED _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a52d: e9 3a 28 00 00 jmp 10cd6c <_Thread_Enable_dispatch> <== 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 98 27 12 00 mov 0x122798,%eax <== NOT EXECUTED 10a78d: 40 inc %eax <== NOT EXECUTED 10a78e: a3 98 27 12 00 mov %eax,0x122798 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 10a793: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a796: 68 a0 26 12 00 push $0x1226a0 <== NOT EXECUTED 10a79b: e8 f4 1d 00 00 call 10c594 <_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 01 15 00 00 call 10bcc0 <_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 bc 26 12 00 mov 0x1226bc,%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 f2 2a 00 00 call 10d2cc <_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 bb 2a 00 00 call 10d2cc <_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 a0 26 12 00 push $0x1226a0 <== NOT EXECUTED 10a83b: e8 48 22 00 00 call 10ca88 <_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 7a 31 00 00 call 10d9d4 <_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 a0 26 12 00 push $0x1226a0 <== NOT EXECUTED 10a862: e8 ad 1d 00 00 call 10c614 <_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 a0 26 12 00 push $0x1226a0 <== NOT EXECUTED 10a86f: e8 e0 20 00 00 call 10c954 <_Objects_Free> <== NOT EXECUTED _Barrier_Free( the_barrier ); _Thread_Enable_dispatch(); 10a874: e8 53 2a 00 00 call 10d2cc <_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 a0 26 12 00 push $0x1226a0 <== NOT EXECUTED 10a8a6: e8 35 23 00 00 call 10cbe0 <_Objects_Name_to_id_u32> <== NOT EXECUTED 10a8ab: 8b 04 85 74 c2 11 00 mov 0x11c274(,%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 a0 26 12 00 push $0x1226a0 <== NOT EXECUTED 10a8d1: e8 b2 21 00 00 call 10ca88 <_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 fb 13 00 00 call 10bcf4 <_CORE_barrier_Release> <== NOT EXECUTED 10a8f9: 89 06 mov %eax,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a8fb: e8 cc 29 00 00 call 10d2cc <_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 a0 26 12 00 push $0x1226a0 <== NOT EXECUTED 10a92c: e8 57 21 00 00 call 10ca88 <_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 d5 13 00 00 call 10bd24 <_CORE_barrier_Wait> <== NOT EXECUTED id, TRUE, timeout, NULL ); _Thread_Enable_dispatch(); 10a94f: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10a952: e8 75 29 00 00 call 10d2cc <_Thread_Enable_dispatch> <== NOT EXECUTED return _Barrier_Translate_core_barrier_return_code( 10a957: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a95a: a1 5c 28 12 00 mov 0x12285c,%eax <== NOT EXECUTED 10a95f: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10a962: e8 65 59 00 00 call 1102cc <_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 0010b668 : uint32_t api, uint32_t class, uint32_t node, uint32_t index ) { 10b668: 55 push %ebp <== NOT EXECUTED 10b669: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b66b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b66e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b671: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10b674: c1 e0 1b shl $0x1b,%eax <== NOT EXECUTED 10b677: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10b67a: 09 d0 or %edx,%eax <== NOT EXECUTED 10b67c: 0b 45 14 or 0x14(%ebp),%eax <== NOT EXECUTED 10b67f: c1 e1 10 shl $0x10,%ecx <== NOT EXECUTED 10b682: 09 c8 or %ecx,%eax <== NOT EXECUTED return _Objects_Build_id( api, class, node, index ); } 10b684: c9 leave <== NOT EXECUTED 10b685: c3 ret <== NOT EXECUTED 0010b688 : char C1, char C2, char C3, char C4 ) { 10b688: 55 push %ebp <== NOT EXECUTED 10b689: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b68b: 0f be 45 0c movsbl 0xc(%ebp),%eax <== NOT EXECUTED 10b68f: c1 e0 10 shl $0x10,%eax <== NOT EXECUTED 10b692: 0f be 55 08 movsbl 0x8(%ebp),%edx <== NOT EXECUTED 10b696: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10b699: 09 d0 or %edx,%eax <== NOT EXECUTED 10b69b: 0f be 55 10 movsbl 0x10(%ebp),%edx <== NOT EXECUTED 10b69f: c1 e2 08 shl $0x8,%edx <== NOT EXECUTED 10b6a2: 09 d0 or %edx,%eax <== NOT EXECUTED 10b6a4: 0f be 55 14 movsbl 0x14(%ebp),%edx <== NOT EXECUTED 10b6a8: 09 d0 or %edx,%eax <== NOT EXECUTED return _Objects_Build_name( C1, C2, C3, C4 ); } 10b6aa: c9 leave <== NOT EXECUTED 10b6ab: 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 e8 8f 11 00 jmp *0x118fe8(,%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 cc f7 11 00 00 cmpb $0x0,0x11f7cc <== NOT EXECUTED 109b51: 74 0d je 109b60 <== NOT EXECUTED return RTEMS_NOT_DEFINED; *the_interval = _TOD_Seconds_since_epoch; 109b53: a1 4c f8 11 00 mov 0x11f84c,%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 80 f9 11 00 divl 0x11f980 <== 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 24 f9 11 00 mov 0x11f924,%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 cc f7 11 00 00 cmpb $0x0,0x11f7cc <== 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 d5 16 00 00 call 10b29c <_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 dc 77 00 00 call 1113c8 <== 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 80 f9 11 00 divl 0x11f980 <== 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 cc f7 11 00 00 cmpb $0x0,0x11f7cc <== 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 2d 16 00 00 call 10b29c <_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 00109e90 : * error code - if unsuccessful */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { 109e90: 55 push %ebp <== NOT EXECUTED 109e91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109e93: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109e96: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !uptime ) 109e99: 85 c0 test %eax,%eax <== NOT EXECUTED 109e9b: 74 13 je 109eb0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime( uptime ); 109e9d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109ea0: 50 push %eax <== NOT EXECUTED 109ea1: e8 a2 17 00 00 call 10b648 <_TOD_Get_uptime> <== NOT EXECUTED 109ea6: 31 c0 xor %eax,%eax <== NOT EXECUTED 109ea8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 109eab: c9 leave <== NOT EXECUTED 109eac: c3 ret <== NOT EXECUTED 109ead: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { if ( !uptime ) 109eb0: b0 09 mov $0x9,%al <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime( uptime ); return RTEMS_SUCCESSFUL; } 109eb2: c9 leave <== NOT EXECUTED 109eb3: 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 a0 b9 12 00 imul 0x12b9a0,%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 d8 b7 12 00 mov 0x12b7d8,%eax <== NOT EXECUTED 10abae: 40 inc %eax <== NOT EXECUTED 10abaf: a3 d8 b7 12 00 mov %eax,0x12b7d8 <== 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 6d 1a 00 00 call 10c62c <_TOD_Set> <== NOT EXECUTED _Thread_Enable_dispatch(); 10abbf: e8 54 2c 00 00 call 10d818 <_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 88 f9 11 00 mov %eax,0x11f988 <== 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 71 16 00 00 call 10b32c <_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 9c f8 11 00 push $0x11f89c <== NOT EXECUTED 109cc3: e8 30 37 00 00 call 10d3f8 <_Watchdog_Tickle> <== NOT EXECUTED _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 109cc8: e8 db 31 00 00 call 10cea8 <_Thread_Tickle_timeslice> <== NOT EXECUTED 109ccd: a0 8c f8 11 00 mov 0x11f88c,%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 b8 f7 11 00 mov 0x11f7b8,%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 03 25 00 00 call 10c1f0 <_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 0010f654 : */ void rtems_debug_disable ( rtems_debug_control to_be_disabled ) { 10f654: 55 push %ebp <== NOT EXECUTED 10f655: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f657: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED _Debug_Level &= ~to_be_disabled; 10f65a: f7 d0 not %eax <== NOT EXECUTED 10f65c: 21 05 80 f8 11 00 and %eax,0x11f880 <== NOT EXECUTED } 10f662: c9 leave <== NOT EXECUTED 10f663: c3 ret <== NOT EXECUTED 0010f644 : */ void rtems_debug_enable ( rtems_debug_control to_be_enabled ) { 10f644: 55 push %ebp <== NOT EXECUTED 10f645: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Debug_Level |= to_be_enabled; 10f647: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10f64a: 09 05 80 f8 11 00 or %eax,0x11f880 <== NOT EXECUTED } 10f650: c9 leave <== NOT EXECUTED 10f651: 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 7c f8 11 00 mov 0x11f87c,%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 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 109d21: 40 inc %eax <== NOT EXECUTED 109d22: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== 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 13 26 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED return( _Thread_Executing->Wait.return_code ); 109d39: a1 7c f8 11 00 mov 0x11f87c,%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 d5 24 00 00 call 10c370 <_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 87 24 00 00 call 10c34c <_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 0010f738 : rtems_status_code rtems_extension_create( rtems_name name, rtems_extensions_table *extension_table, Objects_Id *id ) { 10f738: 55 push %ebp <== NOT EXECUTED 10f739: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f73b: 57 push %edi <== NOT EXECUTED 10f73c: 56 push %esi <== NOT EXECUTED 10f73d: 53 push %ebx <== NOT EXECUTED 10f73e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f741: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10f744: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Extension_Control *the_extension; if ( !id ) 10f747: 85 f6 test %esi,%esi <== NOT EXECUTED 10f749: 74 75 je 10f7c0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10f74b: 85 ff test %edi,%edi <== NOT EXECUTED 10f74d: 75 0d jne 10f75c <== NOT EXECUTED 10f74f: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED ); *id = the_extension->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10f754: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f757: 5b pop %ebx <== NOT EXECUTED 10f758: 5e pop %esi <== NOT EXECUTED 10f759: 5f pop %edi <== NOT EXECUTED 10f75a: c9 leave <== NOT EXECUTED 10f75b: 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 10f75c: a1 b8 dc 12 00 mov 0x12dcb8,%eax <== NOT EXECUTED 10f761: 40 inc %eax <== NOT EXECUTED 10f762: a3 b8 dc 12 00 mov %eax,0x12dcb8 <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 10f767: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f76a: 68 40 df 12 00 push $0x12df40 <== NOT EXECUTED 10f76f: e8 ac 0c 00 00 call 110420 <_Objects_Allocate> <== NOT EXECUTED 10f774: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 10f776: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f779: 85 c0 test %eax,%eax <== NOT EXECUTED 10f77b: 74 37 je 10f7b4 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } _User_extensions_Add_set( &the_extension->Extension, extension_table ); 10f77d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f780: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10f783: 8d 40 10 lea 0x10(%eax),%eax <== NOT EXECUTED 10f786: 50 push %eax <== NOT EXECUTED 10f787: e8 9c 26 00 00 call 111e28 <_User_extensions_Add_set> <== NOT EXECUTED 10f78c: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10f78f: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10f792: a1 5c df 12 00 mov 0x12df5c,%eax <== NOT EXECUTED 10f797: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10f79a: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 10f79d: 89 0e mov %ecx,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10f79f: e8 b4 19 00 00 call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED 10f7a4: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f7a6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10f7a9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f7ac: 5b pop %ebx <== NOT EXECUTED 10f7ad: 5e pop %esi <== NOT EXECUTED 10f7ae: 5f pop %edi <== NOT EXECUTED 10f7af: c9 leave <== NOT EXECUTED 10f7b0: c3 ret <== NOT EXECUTED 10f7b1: 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(); 10f7b4: e8 9f 19 00 00 call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED 10f7b9: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10f7be: eb 94 jmp 10f754 <== NOT EXECUTED Objects_Id *id ) { Extension_Control *the_extension; if ( !id ) 10f7c0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10f7c5: eb 8d jmp 10f754 <== NOT EXECUTED 0010f7c8 : */ rtems_status_code rtems_extension_delete( Objects_Id id ) { 10f7c8: 55 push %ebp <== NOT EXECUTED 10f7c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f7cb: 53 push %ebx <== NOT EXECUTED 10f7cc: 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 10f7cf: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10f7d2: 50 push %eax <== NOT EXECUTED 10f7d3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f7d6: 68 40 df 12 00 push $0x12df40 <== NOT EXECUTED 10f7db: e8 34 11 00 00 call 110914 <_Objects_Get> <== NOT EXECUTED 10f7e0: 89 c3 mov %eax,%ebx <== NOT EXECUTED Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 10f7e2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f7e5: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10f7e8: 85 c0 test %eax,%eax <== NOT EXECUTED 10f7ea: 75 38 jne 10f824 <== NOT EXECUTED case OBJECTS_LOCAL: _User_extensions_Remove_set( &the_extension->Extension ); 10f7ec: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f7ef: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10f7f2: 50 push %eax <== NOT EXECUTED 10f7f3: e8 30 27 00 00 call 111f28 <_User_extensions_Remove_set> <== NOT EXECUTED _Objects_Close( &_Extension_Information, &the_extension->Object ); 10f7f8: 59 pop %ecx <== NOT EXECUTED 10f7f9: 58 pop %eax <== NOT EXECUTED 10f7fa: 53 push %ebx <== NOT EXECUTED 10f7fb: 68 40 df 12 00 push $0x12df40 <== NOT EXECUTED 10f800: e8 9b 0c 00 00 call 1104a0 <_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 10f805: 58 pop %eax <== NOT EXECUTED 10f806: 5a pop %edx <== NOT EXECUTED 10f807: 53 push %ebx <== NOT EXECUTED 10f808: 68 40 df 12 00 push $0x12df40 <== NOT EXECUTED 10f80d: e8 ce 0f 00 00 call 1107e0 <_Objects_Free> <== NOT EXECUTED _Extension_Free( the_extension ); _Thread_Enable_dispatch(); 10f812: e8 41 19 00 00 call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED 10f817: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f819: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f81c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f81f: c9 leave <== NOT EXECUTED 10f820: c3 ret <== NOT EXECUTED 10f821: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 10f824: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f829: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f82c: c9 leave <== NOT EXECUTED 10f82d: c3 ret <== NOT EXECUTED 0010c454 : rtems_status_code rtems_extension_ident( rtems_name name, Objects_Id *id ) { 10c454: 55 push %ebp <== NOT EXECUTED 10c455: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c457: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 10c45a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c45d: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 10c462: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c465: 68 a0 4d 12 00 push $0x124da0 <== NOT EXECUTED 10c46a: e8 45 12 00 00 call 10d6b4 <_Objects_Name_to_id_u32> <== NOT EXECUTED 10c46f: 8b 04 85 94 d6 11 00 mov 0x11d694(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 10c476: c9 leave <== NOT EXECUTED 10c477: c3 ret <== NOT EXECUTED 0010aa48 : */ void rtems_fatal_error_occurred( uint32_t the_error ) { 10aa48: 55 push %ebp <== NOT EXECUTED 10aa49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa4b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, FALSE, the_error ); 10aa4e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10aa51: 6a 00 push $0x0 <== NOT EXECUTED 10aa53: 6a 01 push $0x1 <== NOT EXECUTED 10aa55: e8 26 0b 00 00 call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED 0010c208 : #endif #include const char *rtems_get_version_string(void) { 10c208: 55 push %ebp <== NOT EXECUTED 10c209: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _RTEMS_version; } 10c20b: b8 80 f0 11 00 mov $0x11f080,%eax <== NOT EXECUTED 10c210: c9 leave <== NOT EXECUTED 10c211: 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 4f 03 00 00 jmp 10ac58 <_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 f4 00 00 00 je 10aa15 <== NOT EXECUTED ); /* * Provide pointers just for later convenience. */ _Configuration_Table = configuration_table; 10a921: 89 1d 54 f8 11 00 mov %ebx,0x11f854 <== 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 f0 c1 10 00 push $0x10c1f0 <== NOT EXECUTED 10a92f: e8 ac 2d 00 00 call 10d6e0 <_CPU_Initialize> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** * This routine initializes @a the_heap record to manage the 10a934: c7 05 84 f9 11 00 00 movl $0x0,0x11f984 <== 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 f1 4c 00 00 call 10f634 <_Debug_Manager_initialization> <== NOT EXECUTED _API_extensions_Initialization(); 10a943: e8 ec 02 00 00 call 10ac34 <_API_extensions_Initialization> <== NOT EXECUTED 10a948: c7 05 b8 f7 11 00 01 movl $0x1,0x11f7b8 <== 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 62 2b 00 00 call 10d4c0 <_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 85 26 00 00 call 10cff0 <_User_extensions_Handler_initialization> <== NOT EXECUTED configuration_table->number_of_initial_extensions, configuration_table->User_extension_table ); _ISR_Handler_initialization(); 10a96b: e8 50 0c 00 00 call 10b5c0 <_ISR_Handler_initialization> <== NOT EXECUTED _Objects_Handler_initialization( 10a970: e8 6f 13 00 00 call 10bce4 <_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 90 f7 11 00 d0 movl $0x11f7d0,0x11f790 <== NOT EXECUTED 10a97c: f7 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 01 04 00 00 call 10ad8c <_API_Mutex_Initialization> <== NOT EXECUTED _API_Mutex_Allocate( &_RTEMS_Allocator_Mutex ); 10a98b: c7 04 24 74 f8 11 00 movl $0x11f874,(%esp) <== NOT EXECUTED 10a992: e8 75 03 00 00 call 10ad0c <_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 70 f8 11 00 movw $0x0,0x11f870 <== 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 00 f9 11 movw $0x0,0x11f900(%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 6f 29 00 00 call 10d32c <_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 28 09 00 00 call 10b2f0 <_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 23 1c 00 00 call 10c5f8 <_Thread_Handler_initialization> <== NOT EXECUTED ); #endif /* MANAGERS */ _RTEMS_API_Initialize( configuration_table ); 10a9d5: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a9d8: e8 d3 01 00 00 call 10abb0 <_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 3e 00 00 00 call 10aa24 <_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 95 00 00 00 call 10aa8c <_IO_Manager_initialization> <== NOT EXECUTED configuration_table->number_of_device_drivers, configuration_table->maximum_drivers ); #ifdef RTEMS_POSIX_API _POSIX_API_Initialize( configuration_table ); 10a9f7: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a9fa: e8 15 01 00 00 call 10ab14 <_POSIX_API_Initialize> <== 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( 10a9ff: c7 05 84 f9 11 00 01 movl $0x1,0x11f984 <== NOT EXECUTED 10aa06: 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(); 10aa09: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Scheduling can properly occur now as long as we avoid dispatching. */ } 10aa0c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10aa0f: 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(); 10aa10: e9 03 17 00 00 jmp 10c118 <_Thread_Create_idle> <== NOT EXECUTED /* * Make sure the parameters were not NULL. */ if ( configuration_table == NULL ) _Internal_error_Occurred( 10aa15: 50 push %eax <== NOT EXECUTED 10aa16: 6a 00 push $0x0 <== NOT EXECUTED 10aa18: 6a 01 push $0x1 <== NOT EXECUTED 10aa1a: 6a 00 push $0x0 <== NOT EXECUTED 10aa1c: e8 5f 0b 00 00 call 10b580 <_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 65 01 00 00 call 10aa5c <_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 8b 03 00 00 jmp 10ac88 <_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 84 f9 11 00 02 movl $0x2,0x11f984 <== 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 01 25 00 00 jmp 10cdec <_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 d8 27 12 00 mov 0x1227d8,%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 001108e4 : rtems_status_code rtems_io_close( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 1108e4: 55 push %ebp <== NOT EXECUTED 1108e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1108e7: 56 push %esi <== NOT EXECUTED 1108e8: 53 push %ebx <== NOT EXECUTED 1108e9: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1108ec: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1108ef: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 1108f2: 39 0d 20 02 12 00 cmp %ecx,0x120220 <== NOT EXECUTED 1108f8: 76 1e jbe 110918 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; 1108fa: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 1108fd: a1 24 02 12 00 mov 0x120224,%eax <== NOT EXECUTED 110902: 8b 44 d0 08 mov 0x8(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 110906: 85 c0 test %eax,%eax <== NOT EXECUTED 110908: 74 13 je 11091d <== NOT EXECUTED 11090a: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 11090d: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 110910: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 110913: 5b pop %ebx <== NOT EXECUTED 110914: 5e pop %esi <== NOT EXECUTED 110915: 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; 110916: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 110918: 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; } 11091d: 5b pop %ebx <== NOT EXECUTED 11091e: 5e pop %esi <== NOT EXECUTED 11091f: c9 leave <== NOT EXECUTED 110920: c3 ret <== NOT EXECUTED 00110924 : rtems_status_code rtems_io_control( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 110924: 55 push %ebp <== NOT EXECUTED 110925: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110927: 56 push %esi <== NOT EXECUTED 110928: 53 push %ebx <== NOT EXECUTED 110929: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 11092c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 11092f: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 110932: 39 0d 20 02 12 00 cmp %ecx,0x120220 <== NOT EXECUTED 110938: 76 1e jbe 110958 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; 11093a: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 11093d: a1 24 02 12 00 mov 0x120224,%eax <== NOT EXECUTED 110942: 8b 44 d0 14 mov 0x14(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 110946: 85 c0 test %eax,%eax <== NOT EXECUTED 110948: 74 13 je 11095d <== NOT EXECUTED 11094a: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 11094d: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 110950: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 110953: 5b pop %ebx <== NOT EXECUTED 110954: 5e pop %esi <== NOT EXECUTED 110955: 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; 110956: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 110958: 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; } 11095d: 5b pop %ebx <== NOT EXECUTED 11095e: 5e pop %esi <== NOT EXECUTED 11095f: c9 leave <== NOT EXECUTED 110960: c3 ret <== NOT EXECUTED 0010f678 : rtems_status_code rtems_io_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10f678: 55 push %ebp <== NOT EXECUTED 10f679: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f67b: 56 push %esi <== NOT EXECUTED 10f67c: 53 push %ebx <== NOT EXECUTED 10f67d: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10f680: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10f683: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10f686: 39 0d 20 02 12 00 cmp %ecx,0x120220 <== NOT EXECUTED 10f68c: 76 1e jbe 10f6ac <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; 10f68e: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 10f691: a1 24 02 12 00 mov 0x120224,%eax <== NOT EXECUTED 10f696: 8b 04 d0 mov (%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10f699: 85 c0 test %eax,%eax <== NOT EXECUTED 10f69b: 74 14 je 10f6b1 <== NOT EXECUTED 10f69d: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10f6a0: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10f6a3: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10f6a6: 5b pop %ebx <== NOT EXECUTED 10f6a7: 5e pop %esi <== NOT EXECUTED 10f6a8: 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; 10f6a9: ff e0 jmp *%eax <== NOT EXECUTED 10f6ab: 90 nop <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10f6ac: 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; } 10f6b1: 5b pop %ebx <== NOT EXECUTED 10f6b2: 5e pop %esi <== NOT EXECUTED 10f6b3: c9 leave <== NOT EXECUTED 10f6b4: c3 ret <== NOT EXECUTED 00110964 : rtems_status_code rtems_io_open( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 110964: 55 push %ebp <== NOT EXECUTED 110965: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110967: 56 push %esi <== NOT EXECUTED 110968: 53 push %ebx <== NOT EXECUTED 110969: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 11096c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 11096f: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 110972: 39 0d 20 02 12 00 cmp %ecx,0x120220 <== NOT EXECUTED 110978: 76 1e jbe 110998 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; 11097a: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 11097d: a1 24 02 12 00 mov 0x120224,%eax <== NOT EXECUTED 110982: 8b 44 d0 04 mov 0x4(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 110986: 85 c0 test %eax,%eax <== NOT EXECUTED 110988: 74 13 je 11099d <== NOT EXECUTED 11098a: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 11098d: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 110990: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 110993: 5b pop %ebx <== NOT EXECUTED 110994: 5e pop %esi <== NOT EXECUTED 110995: 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; 110996: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 110998: 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; } 11099d: 5b pop %ebx <== NOT EXECUTED 11099e: 5e pop %esi <== NOT EXECUTED 11099f: c9 leave <== NOT EXECUTED 1109a0: c3 ret <== NOT EXECUTED 001109a4 : rtems_status_code rtems_io_read( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 1109a4: 55 push %ebp <== NOT EXECUTED 1109a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1109a7: 56 push %esi <== NOT EXECUTED 1109a8: 53 push %ebx <== NOT EXECUTED 1109a9: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1109ac: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1109af: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 1109b2: 39 0d 20 02 12 00 cmp %ecx,0x120220 <== NOT EXECUTED 1109b8: 76 1e jbe 1109d8 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; 1109ba: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 1109bd: a1 24 02 12 00 mov 0x120224,%eax <== NOT EXECUTED 1109c2: 8b 44 d0 0c mov 0xc(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 1109c6: 85 c0 test %eax,%eax <== NOT EXECUTED 1109c8: 74 13 je 1109dd <== NOT EXECUTED 1109ca: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 1109cd: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 1109d0: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 1109d3: 5b pop %ebx <== NOT EXECUTED 1109d4: 5e pop %esi <== NOT EXECUTED 1109d5: 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; 1109d6: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 1109d8: 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; } 1109dd: 5b pop %ebx <== NOT EXECUTED 1109de: 5e pop %esi <== NOT EXECUTED 1109df: c9 leave <== NOT EXECUTED 1109e0: c3 ret <== NOT EXECUTED 0010b894 : 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 ) { 10b894: 55 push %ebp <== NOT EXECUTED 10b895: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b897: 57 push %edi <== NOT EXECUTED 10b898: 56 push %esi <== NOT EXECUTED 10b899: 53 push %ebx <== NOT EXECUTED 10b89a: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b89d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b8a0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10b8a3: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 10b8a6: 85 f6 test %esi,%esi <== NOT EXECUTED 10b8a8: 0f 84 c6 00 00 00 je 10b974 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 10b8ae: 85 db test %ebx,%ebx <== NOT EXECUTED 10b8b0: 0f 84 be 00 00 00 je 10b974 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 10b8b6: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10b8b8: 85 c0 test %eax,%eax <== NOT EXECUTED 10b8ba: 0f 84 a8 00 00 00 je 10b968 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; *registered_major = 0; 10b8c0: 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 ) 10b8c6: a1 24 2a 12 00 mov 0x122a24,%eax <== NOT EXECUTED 10b8cb: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10b8cd: 76 5d jbe 10b92c <== NOT EXECUTED /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 10b8cf: 85 d2 test %edx,%edx <== NOT EXECUTED 10b8d1: 75 65 jne 10b938 <== NOT EXECUTED bool found = false; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 10b8d3: 89 c2 mov %eax,%edx <== NOT EXECUTED 10b8d5: 4a dec %edx <== NOT EXECUTED 10b8d6: 0f 84 80 00 00 00 je 10b95c <== NOT EXECUTED 10b8dc: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10b8df: 8d 04 c5 e8 ff ff ff lea -0x18(,%eax,8),%eax <== NOT EXECUTED 10b8e6: 03 05 28 2a 12 00 add 0x122a28,%eax <== NOT EXECUTED 10b8ec: eb 08 jmp 10b8f6 <== NOT EXECUTED 10b8ee: 66 90 xchg %ax,%ax <== NOT EXECUTED 10b8f0: 83 e8 18 sub $0x18,%eax <== NOT EXECUTED 10b8f3: 4a dec %edx <== NOT EXECUTED 10b8f4: 74 66 je 10b95c <== NOT EXECUTED 10b8f6: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( !_IO_Driver_address_table[major].initialization_entry && 10b8f8: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10b8fa: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b8fc: 75 f2 jne 10b8f0 <== NOT EXECUTED 10b8fe: 8b 48 04 mov 0x4(%eax),%ecx <== NOT EXECUTED 10b901: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b903: 75 eb jne 10b8f0 <== 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; 10b905: b8 06 00 00 00 mov $0x6,%eax <== NOT EXECUTED 10b90a: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b90c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *registered_major = major; 10b90e: 89 13 mov %edx,(%ebx) <== NOT EXECUTED return rtems_io_initialize( major, 0, NULL ); 10b910: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) <== NOT EXECUTED 10b917: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) <== NOT EXECUTED 10b91e: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10b921: 59 pop %ecx <== NOT EXECUTED 10b922: 5b pop %ebx <== NOT EXECUTED 10b923: 5e pop %esi <== NOT EXECUTED 10b924: 5f pop %edi <== NOT EXECUTED 10b925: c9 leave <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10b926: e9 f1 fd ff ff jmp 10b71c <== NOT EXECUTED 10b92b: 90 nop <== NOT EXECUTED *registered_major = 0; /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 10b92c: 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 ); } 10b931: 5a pop %edx <== NOT EXECUTED 10b932: 5b pop %ebx <== NOT EXECUTED 10b933: 5e pop %esi <== NOT EXECUTED 10b934: 5f pop %edi <== NOT EXECUTED 10b935: c9 leave <== NOT EXECUTED 10b936: c3 ret <== NOT EXECUTED 10b937: 90 nop <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 10b938: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10b93b: 8d 3c c5 00 00 00 00 lea 0x0(,%eax,8),%edi <== NOT EXECUTED 10b942: 03 3d 28 2a 12 00 add 0x122a28,%edi <== NOT EXECUTED 10b948: 8b 07 mov (%edi),%eax <== NOT EXECUTED 10b94a: 85 c0 test %eax,%eax <== NOT EXECUTED 10b94c: 74 32 je 10b980 <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10b94e: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED } 10b953: 5a pop %edx <== NOT EXECUTED 10b954: 5b pop %ebx <== NOT EXECUTED 10b955: 5e pop %esi <== NOT EXECUTED 10b956: 5f pop %edi <== NOT EXECUTED 10b957: c9 leave <== NOT EXECUTED 10b958: c3 ret <== NOT EXECUTED 10b959: 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 ); 10b95c: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED } 10b961: 5a pop %edx <== NOT EXECUTED 10b962: 5b pop %ebx <== NOT EXECUTED 10b963: 5e pop %esi <== NOT EXECUTED 10b964: 5f pop %edi <== NOT EXECUTED 10b965: c9 leave <== NOT EXECUTED 10b966: c3 ret <== NOT EXECUTED 10b967: 90 nop <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !registered_major ) return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 10b968: 8b 7e 04 mov 0x4(%esi),%edi <== NOT EXECUTED 10b96b: 85 ff test %edi,%edi <== NOT EXECUTED 10b96d: 0f 85 4d ff ff ff jne 10b8c0 <== NOT EXECUTED 10b973: 90 nop <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10b974: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED } 10b979: 5a pop %edx <== NOT EXECUTED 10b97a: 5b pop %ebx <== NOT EXECUTED 10b97b: 5e pop %esi <== NOT EXECUTED 10b97c: 5f pop %edi <== NOT EXECUTED 10b97d: c9 leave <== NOT EXECUTED 10b97e: c3 ret <== NOT EXECUTED 10b97f: 90 nop <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 10b980: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 10b983: 85 c0 test %eax,%eax <== NOT EXECUTED 10b985: 75 c7 jne 10b94e <== NOT EXECUTED 10b987: e9 79 ff ff ff jmp 10b905 <== NOT EXECUTED 0010b98c : */ rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { 10b98c: 55 push %ebp <== NOT EXECUTED 10b98d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b98f: 57 push %edi <== NOT EXECUTED 10b990: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b993: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( major < _IO_Number_of_drivers ) { 10b996: 39 05 24 2a 12 00 cmp %eax,0x122a24 <== NOT EXECUTED 10b99c: 77 0a ja 10b9a8 <== NOT EXECUTED 10b99e: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED sizeof( rtems_driver_address_table ) ); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 10b9a3: 5a pop %edx <== NOT EXECUTED 10b9a4: 5f pop %edi <== NOT EXECUTED 10b9a5: c9 leave <== NOT EXECUTED 10b9a6: c3 ret <== NOT EXECUTED 10b9a7: 90 nop <== NOT EXECUTED rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { if ( major < _IO_Number_of_drivers ) { memset( 10b9a8: 8d 3c 40 lea (%eax,%eax,2),%edi <== NOT EXECUTED 10b9ab: c1 e7 03 shl $0x3,%edi <== NOT EXECUTED 10b9ae: 03 3d 28 2a 12 00 add 0x122a28,%edi <== NOT EXECUTED 10b9b4: b9 18 00 00 00 mov $0x18,%ecx <== NOT EXECUTED 10b9b9: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b9bb: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 10b9bd: 31 c0 xor %eax,%eax <== NOT EXECUTED sizeof( rtems_driver_address_table ) ); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 10b9bf: 5a pop %edx <== NOT EXECUTED 10b9c0: 5f pop %edi <== NOT EXECUTED 10b9c1: c9 leave <== NOT EXECUTED 10b9c2: c3 ret <== NOT EXECUTED 001109e4 : rtems_status_code rtems_io_write( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 1109e4: 55 push %ebp <== NOT EXECUTED 1109e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1109e7: 56 push %esi <== NOT EXECUTED 1109e8: 53 push %ebx <== NOT EXECUTED 1109e9: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1109ec: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1109ef: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 1109f2: 39 0d 20 02 12 00 cmp %ecx,0x120220 <== NOT EXECUTED 1109f8: 76 1e jbe 110a18 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; 1109fa: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 1109fd: a1 24 02 12 00 mov 0x120224,%eax <== NOT EXECUTED 110a02: 8b 44 d0 10 mov 0x10(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 110a06: 85 c0 test %eax,%eax <== NOT EXECUTED 110a08: 74 13 je 110a1d <== NOT EXECUTED 110a0a: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 110a0d: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 110a10: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 110a13: 5b pop %ebx <== NOT EXECUTED 110a14: 5e pop %esi <== NOT EXECUTED 110a15: 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; 110a16: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 110a18: 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; } 110a1d: 5b pop %ebx <== NOT EXECUTED 110a1e: 5e pop %esi <== NOT EXECUTED 110a1f: c9 leave <== NOT EXECUTED 110a20: c3 ret <== NOT EXECUTED 0010c980 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10c980: 55 push %ebp <== NOT EXECUTED 10c981: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c983: 57 push %edi <== NOT EXECUTED 10c984: 56 push %esi <== NOT EXECUTED 10c985: 53 push %ebx <== NOT EXECUTED 10c986: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10c989: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c98c: 85 c0 test %eax,%eax <== NOT EXECUTED 10c98e: 74 47 je 10c9d7 <== NOT EXECUTED return; 10c990: 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 ] ) 10c995: 8b 04 bd ac b7 12 00 mov 0x12b7ac(,%edi,4),%eax <== NOT EXECUTED 10c99c: 85 c0 test %eax,%eax <== NOT EXECUTED 10c99e: 74 31 je 10c9d1 <== NOT EXECUTED continue; information = _Objects_Information_table[ api_index ][ 1 ]; 10c9a0: 8b 70 04 mov 0x4(%eax),%esi <== NOT EXECUTED if ( information ) { 10c9a3: 85 f6 test %esi,%esi <== NOT EXECUTED 10c9a5: 74 2a je 10c9d1 <== NOT EXECUTED for ( i=1 ; i <= information->maximum ; i++ ) { 10c9a7: 66 83 7e 10 00 cmpw $0x0,0x10(%esi) <== NOT EXECUTED 10c9ac: 74 23 je 10c9d1 <== NOT EXECUTED 10c9ae: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10c9b3: 90 nop <== NOT EXECUTED the_thread = (Thread_Control *)information->local_table[ i ]; 10c9b4: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED 10c9b7: 8b 04 98 mov (%eax,%ebx,4),%eax <== NOT EXECUTED if ( !the_thread ) 10c9ba: 85 c0 test %eax,%eax <== NOT EXECUTED 10c9bc: 74 0a je 10c9c8 <== NOT EXECUTED continue; (*routine)(the_thread); 10c9be: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c9c1: 50 push %eax <== NOT EXECUTED 10c9c2: ff 55 08 call *0x8(%ebp) <== NOT EXECUTED 10c9c5: 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++ ) { 10c9c8: 43 inc %ebx <== NOT EXECUTED 10c9c9: 0f b7 46 10 movzwl 0x10(%esi),%eax <== NOT EXECUTED 10c9cd: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10c9cf: 73 e3 jae 10c9b4 <== NOT EXECUTED if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10c9d1: 47 inc %edi <== NOT EXECUTED if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 10c9d2: 83 ff 05 cmp $0x5,%edi <== NOT EXECUTED 10c9d5: 75 be jne 10c995 <== NOT EXECUTED (*routine)(the_thread); } } } } 10c9d7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c9da: 5b pop %ebx <== NOT EXECUTED 10c9db: 5e pop %esi <== NOT EXECUTED 10c9dc: 5f pop %edi <== NOT EXECUTED 10c9dd: c9 leave <== NOT EXECUTED 10c9de: 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 60 77 13 00 push $0x137760 <== NOT EXECUTED 11234d: e8 ee 48 00 00 call 116c40 <_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 1c 32 00 00 call 11559c <_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 fa 50 00 00 call 117484 <_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 f8 1e 16 00 mov 0x161ef8,%eax <== NOT EXECUTED 10eebd: 40 inc %eax <== NOT EXECUTED 10eebe: a3 f8 1e 16 00 mov %eax,0x161ef8 <== NOT EXECUTED #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); 10eec3: e8 e8 71 01 00 call 1260b0 <_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 72 0f 00 00 call 10fe64 <_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 40 2a 16 00 push $0x162a40 <== NOT EXECUTED 10ef02: e8 49 1d 00 00 call 110c50 <_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 6c 28 00 00 call 111778 <_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 5c 2a 16 00 mov 0x162a5c,%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 39 28 00 00 call 111778 <_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 2b 28 00 00 call 111778 <_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 00115fb8 : */ rtems_status_code rtems_message_queue_delete( Objects_Id id ) { 115fb8: 55 push %ebp <== NOT EXECUTED 115fb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 115fbb: 53 push %ebx <== NOT EXECUTED 115fbc: 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, 115fbf: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 115fc2: 50 push %eax <== NOT EXECUTED 115fc3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 115fc6: 68 20 e7 12 00 push $0x12e720 <== NOT EXECUTED 115fcb: e8 44 a9 ff ff call 110914 <_Objects_Get> <== NOT EXECUTED 115fd0: 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 ) { 115fd2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115fd5: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 115fd8: 85 c9 test %ecx,%ecx <== NOT EXECUTED 115fda: 75 3c jne 116018 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, 115fdc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 115fdf: 50 push %eax <== NOT EXECUTED 115fe0: 68 20 e7 12 00 push $0x12e720 <== NOT EXECUTED 115fe5: e8 b6 a4 ff ff call 1104a0 <_Objects_Close> <== NOT EXECUTED &the_message_queue->Object ); _CORE_message_queue_Close( 115fea: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 115fed: 6a 05 push $0x5 <== NOT EXECUTED 115fef: 6a 00 push $0x0 <== NOT EXECUTED 115ff1: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 115ff4: 50 push %eax <== NOT EXECUTED 115ff5: e8 ce 04 00 00 call 1164c8 <_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, 115ffa: 58 pop %eax <== NOT EXECUTED 115ffb: 5a pop %edx <== NOT EXECUTED 115ffc: 53 push %ebx <== NOT EXECUTED 115ffd: 68 20 e7 12 00 push $0x12e720 <== NOT EXECUTED 116002: e8 d9 a7 ff ff call 1107e0 <_Objects_Free> <== NOT EXECUTED 0, /* Not used */ 0 ); } #endif _Thread_Enable_dispatch(); 116007: e8 4c b1 ff ff call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED 11600c: 31 c0 xor %eax,%eax <== NOT EXECUTED 11600e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116011: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 116014: c9 leave <== NOT EXECUTED 116015: c3 ret <== NOT EXECUTED 116016: 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 ) { 116018: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11601d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 116020: c9 leave <== NOT EXECUTED 116021: 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 60 77 13 00 push $0x137760 <== NOT EXECUTED 112523: e8 18 47 00 00 call 116c40 <_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 0c 31 00 00 call 115654 <_CORE_message_queue_Flush> <== NOT EXECUTED 112548: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 11254a: e8 35 4f 00 00 call 117484 <_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 60 77 13 00 push $0x137760 <== NOT EXECUTED 112583: e8 b8 46 00 00 call 116c40 <_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 de 4e 00 00 call 117484 <_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 a0 01 12 00 push $0x1201a0 <== NOT EXECUTED 10a090: e8 cb 1b 00 00 call 10bc60 <_Objects_Name_to_id_u32> <== NOT EXECUTED 10a095: 8b 04 85 d4 90 11 00 mov 0x1190d4(,%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 00116024 : void *buffer, size_t *size, rtems_option option_set, rtems_interval timeout ) { 116024: 55 push %ebp <== NOT EXECUTED 116025: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116027: 57 push %edi <== NOT EXECUTED 116028: 56 push %esi <== NOT EXECUTED 116029: 53 push %ebx <== NOT EXECUTED 11602a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 11602d: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 116030: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 116033: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; bool wait; if ( !buffer ) 116036: 85 ff test %edi,%edi <== NOT EXECUTED 116038: 74 6e je 1160a8 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !size ) 11603a: 85 f6 test %esi,%esi <== NOT EXECUTED 11603c: 74 6a je 1160a8 <== 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, 11603e: 51 push %ecx <== NOT EXECUTED 11603f: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 116042: 50 push %eax <== NOT EXECUTED 116043: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 116046: 68 20 e7 12 00 push $0x12e720 <== NOT EXECUTED 11604b: e8 c4 a8 ff ff call 110914 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 116050: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116053: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 116056: 85 d2 test %edx,%edx <== NOT EXECUTED 116058: 75 3e jne 116098 <== NOT EXECUTED if ( _Options_Is_no_wait( option_set ) ) wait = false; else wait = true; _CORE_message_queue_Seize( 11605a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11605d: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 116060: 83 f3 01 xor $0x1,%ebx <== NOT EXECUTED 116063: 83 e3 01 and $0x1,%ebx <== NOT EXECUTED 116066: 53 push %ebx <== NOT EXECUTED 116067: 56 push %esi <== NOT EXECUTED 116068: 57 push %edi <== NOT EXECUTED 116069: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 11606c: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 11606f: 50 push %eax <== NOT EXECUTED 116070: e8 b7 05 00 00 call 11662c <_CORE_message_queue_Seize> <== NOT EXECUTED buffer, size, wait, timeout ); _Thread_Enable_dispatch(); 116075: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 116078: e8 db b0 ff ff call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code( 11607d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 116080: a1 7c dd 12 00 mov 0x12dd7c,%eax <== NOT EXECUTED 116085: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 116088: e8 87 8b ff ff call 10ec14 <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 11608d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116090: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116093: 5b pop %ebx <== NOT EXECUTED 116094: 5e pop %esi <== NOT EXECUTED 116095: 5f pop %edi <== NOT EXECUTED 116096: c9 leave <== NOT EXECUTED 116097: c3 ret <== NOT EXECUTED if ( !size ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 116098: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11609d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1160a0: 5b pop %ebx <== NOT EXECUTED 1160a1: 5e pop %esi <== NOT EXECUTED 1160a2: 5f pop %edi <== NOT EXECUTED 1160a3: c9 leave <== NOT EXECUTED 1160a4: c3 ret <== NOT EXECUTED 1160a5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 1160a8: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1160ad: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1160b0: 5b pop %ebx <== NOT EXECUTED 1160b1: 5e pop %esi <== NOT EXECUTED 1160b2: 5f pop %edi <== NOT EXECUTED 1160b3: c9 leave <== NOT EXECUTED 1160b4: 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 a0 01 12 00 push $0x1201a0 <== NOT EXECUTED 10a0bd: e8 46 1a 00 00 call 10bb08 <_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 37 0d 00 00 call 10ae28 <_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 51 22 00 00 call 10c34c <_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 60 77 13 00 push $0x137760 <== NOT EXECUTED 11271d: e8 1e 45 00 00 call 116c40 <_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 4b 31 00 00 call 11589c <_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 29 4d 00 00 call 117484 <_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 0010a5dc : #include int rtems_object_api_maximum_class( uint32_t api ) { 10a5dc: 55 push %ebp <== NOT EXECUTED 10a5dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_API_maximum_class(api); } 10a5df: c9 leave <== NOT EXECUTED int rtems_object_api_maximum_class( uint32_t api ) { return _Objects_API_maximum_class(api); 10a5e0: e9 f7 15 00 00 jmp 10bbdc <_Objects_API_maximum_class> <== NOT EXECUTED 0010a5e8 : #include uint32_t rtems_object_api_minimum_class( uint32_t api ) { 10a5e8: 55 push %ebp <== NOT EXECUTED 10a5e9: 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. 10a5eb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a5ee: 48 dec %eax <== NOT EXECUTED 10a5ef: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10a5f2: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10a5f4: 83 e0 02 and $0x2,%eax <== NOT EXECUTED 10a5f7: 48 dec %eax <== NOT EXECUTED if ( _Objects_Is_api_valid( api ) ) return 1; return -1; } 10a5f8: c9 leave <== NOT EXECUTED 10a5f9: c3 ret <== NOT EXECUTED 0010a5fc : const char *rtems_object_get_api_class_name( uint32_t the_api, uint32_t the_class ) { 10a5fc: 55 push %ebp <== NOT EXECUTED 10a5fd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a5ff: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a602: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) 10a605: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10a608: 74 36 je 10a640 <== NOT EXECUTED api_assoc = rtems_object_api_internal_assoc; else if ( the_api == OBJECTS_CLASSIC_API ) 10a60a: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10a60d: 74 0d je 10a61c <== NOT EXECUTED api_assoc = rtems_object_api_classic_assoc; #ifdef RTEMS_POSIX_API else if ( the_api == OBJECTS_POSIX_API ) 10a60f: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10a612: 74 24 je 10a638 <== NOT EXECUTED 10a614: b8 f0 b9 11 00 mov $0x11b9f0,%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"; } 10a619: c9 leave <== NOT EXECUTED 10a61a: c3 ret <== NOT EXECUTED 10a61b: 90 nop <== 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 ) 10a61c: b8 80 0b 12 00 mov $0x120b80,%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 ); 10a621: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a624: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a627: 50 push %eax <== NOT EXECUTED 10a628: e8 93 45 00 00 call 10ebc0 <== NOT EXECUTED if ( class_assoc ) 10a62d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a630: 85 c0 test %eax,%eax <== NOT EXECUTED 10a632: 74 14 je 10a648 <== NOT EXECUTED return class_assoc->name; 10a634: 8b 00 mov (%eax),%eax <== NOT EXECUTED return "BAD CLASS"; } 10a636: c9 leave <== NOT EXECUTED 10a637: c3 ret <== NOT EXECUTED if ( the_api == OBJECTS_INTERNAL_API ) api_assoc = rtems_object_api_internal_assoc; else if ( the_api == OBJECTS_CLASSIC_API ) api_assoc = rtems_object_api_classic_assoc; #ifdef RTEMS_POSIX_API else if ( the_api == OBJECTS_POSIX_API ) 10a638: b8 00 0c 12 00 mov $0x120c00,%eax <== NOT EXECUTED 10a63d: eb e2 jmp 10a621 <== NOT EXECUTED 10a63f: 90 nop <== NOT EXECUTED ) { const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) 10a640: b8 60 0b 12 00 mov $0x120b60,%eax <== NOT EXECUTED 10a645: eb da jmp 10a621 <== NOT EXECUTED 10a647: 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 ) 10a648: b8 f8 b9 11 00 mov $0x11b9f8,%eax <== NOT EXECUTED return class_assoc->name; return "BAD CLASS"; } 10a64d: c9 leave <== NOT EXECUTED 10a64e: c3 ret <== NOT EXECUTED 0010a650 : }; const char *rtems_object_get_api_name( uint32_t api ) { 10a650: 55 push %ebp <== NOT EXECUTED 10a651: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a653: 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 ); 10a656: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a659: 68 a0 0c 12 00 push $0x120ca0 <== NOT EXECUTED 10a65e: e8 5d 45 00 00 call 10ebc0 <== NOT EXECUTED if ( api_assoc ) 10a663: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a666: 85 c0 test %eax,%eax <== NOT EXECUTED 10a668: 74 06 je 10a670 <== NOT EXECUTED return api_assoc->name; 10a66a: 8b 00 mov (%eax),%eax <== NOT EXECUTED return "BAD CLASS"; } 10a66c: c9 leave <== NOT EXECUTED 10a66d: c3 ret <== NOT EXECUTED 10a66e: 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 ) 10a670: b8 f8 b9 11 00 mov $0x11b9f8,%eax <== NOT EXECUTED return api_assoc->name; return "BAD CLASS"; } 10a675: c9 leave <== NOT EXECUTED 10a676: c3 ret <== NOT EXECUTED 0010b788 : rtems_status_code rtems_object_get_class_information( uint32_t the_api, uint32_t the_class, rtems_object_api_class_information *info ) { 10b788: 55 push %ebp <== NOT EXECUTED 10b789: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b78b: 56 push %esi <== NOT EXECUTED 10b78c: 53 push %ebx <== NOT EXECUTED 10b78d: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED uint32_t i; /* * Validate parameters and look up information structure. */ if ( !info ) 10b790: 85 f6 test %esi,%esi <== NOT EXECUTED 10b792: 74 58 je 10b7ec <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); 10b794: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b797: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b79a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b79d: e8 c6 1a 00 00 call 10d268 <_Objects_Get_information> <== NOT EXECUTED 10b7a2: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !obj_info ) 10b7a4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b7a7: 85 c0 test %eax,%eax <== NOT EXECUTED 10b7a9: 74 4d je 10b7f8 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 10b7ab: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10b7ae: 89 06 mov %eax,(%esi) <== NOT EXECUTED info->maximum_id = obj_info->maximum_id; 10b7b0: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10b7b3: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED info->auto_extend = obj_info->auto_extend; 10b7b6: 8a 42 12 mov 0x12(%edx),%al <== NOT EXECUTED 10b7b9: 88 46 0c mov %al,0xc(%esi) <== NOT EXECUTED info->maximum = obj_info->maximum; 10b7bc: 0f b7 42 10 movzwl 0x10(%edx),%eax <== NOT EXECUTED 10b7c0: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 10b7c3: 85 c0 test %eax,%eax <== NOT EXECUTED 10b7c5: 74 3d je 10b804 <== NOT EXECUTED 10b7c7: 8b 5a 1c mov 0x1c(%edx),%ebx <== NOT EXECUTED 10b7ca: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10b7cc: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10b7d1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !obj_info->local_table[i] ) unallocated++; 10b7d4: 83 3c 93 01 cmpl $0x1,(%ebx,%edx,4) <== NOT EXECUTED 10b7d8: 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++ ) 10b7db: 42 inc %edx <== NOT EXECUTED 10b7dc: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10b7de: 73 f4 jae 10b7d4 <== NOT EXECUTED if ( !obj_info->local_table[i] ) unallocated++; info->unallocated = unallocated; 10b7e0: 89 4e 10 mov %ecx,0x10(%esi) <== NOT EXECUTED 10b7e3: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10b7e5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b7e8: 5b pop %ebx <== NOT EXECUTED 10b7e9: 5e pop %esi <== NOT EXECUTED 10b7ea: c9 leave <== NOT EXECUTED 10b7eb: c3 ret <== NOT EXECUTED uint32_t i; /* * Validate parameters and look up information structure. */ if ( !info ) 10b7ec: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED unallocated++; info->unallocated = unallocated; return RTEMS_SUCCESSFUL; } 10b7f1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b7f4: 5b pop %ebx <== NOT EXECUTED 10b7f5: 5e pop %esi <== NOT EXECUTED 10b7f6: c9 leave <== NOT EXECUTED 10b7f7: c3 ret <== NOT EXECUTED */ if ( !info ) return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); if ( !obj_info ) 10b7f8: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED unallocated++; info->unallocated = unallocated; return RTEMS_SUCCESSFUL; } 10b7fd: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b800: 5b pop %ebx <== NOT EXECUTED 10b801: 5e pop %esi <== NOT EXECUTED 10b802: c9 leave <== NOT EXECUTED 10b803: 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++ ) 10b804: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10b806: eb d8 jmp 10b7e0 <== 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 77 1b 00 00 call 10cb9c <_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 74 c4 11 00 mov 0x11c474(,%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 0011612c : char *rtems_object_get_name( Objects_Id id, size_t length, char *name ) { 11612c: 55 push %ebp <== NOT EXECUTED 11612d: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_Get_name_as_string( id, length, name ); } 11612f: c9 leave <== NOT EXECUTED Objects_Id id, size_t length, char *name ) { return _Objects_Get_name_as_string( id, length, name ); 116130: e9 9f 09 00 00 jmp 116ad4 <_Objects_Get_name_as_string> <== NOT EXECUTED 0010b814 : #include #include #undef rtems_object_id_api_maximum uint32_t rtems_object_id_api_maximum(void) { 10b814: 55 push %ebp <== NOT EXECUTED 10b815: 89 e5 mov %esp,%ebp <== NOT EXECUTED return OBJECTS_ITRON_API; } 10b817: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10b81c: c9 leave <== NOT EXECUTED 10b81d: c3 ret <== NOT EXECUTED 0010b820 : #include #include #undef rtems_object_id_api_minimum uint32_t rtems_object_id_api_minimum(void) { 10b820: 55 push %ebp <== NOT EXECUTED 10b821: 89 e5 mov %esp,%ebp <== NOT EXECUTED return OBJECTS_INTERNAL_API; } 10b823: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10b828: c9 leave <== NOT EXECUTED 10b829: c3 ret <== NOT EXECUTED 0010b82c : #undef rtems_object_id_get_api uint32_t rtems_object_id_get_api( rtems_id id ) { 10b82c: 55 push %ebp <== NOT EXECUTED 10b82d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b82f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b832: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10b835: 83 e0 07 and $0x7,%eax <== NOT EXECUTED return _Objects_Get_API( id ); } 10b838: c9 leave <== NOT EXECUTED 10b839: c3 ret <== NOT EXECUTED 0010b83c : #undef rtems_object_id_get_class uint32_t rtems_object_id_get_class( rtems_id id ) { 10b83c: 55 push %ebp <== NOT EXECUTED 10b83d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b83f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b842: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED return _Objects_Get_class( id ); } 10b845: c9 leave <== NOT EXECUTED 10b846: c3 ret <== NOT EXECUTED 0010b848 : #undef rtems_object_id_get_index uint32_t rtems_object_id_get_index( rtems_id id ) { 10b848: 55 push %ebp <== NOT EXECUTED 10b849: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b84b: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED return _Objects_Get_index( id ); } 10b84f: c9 leave <== NOT EXECUTED 10b850: c3 ret <== NOT EXECUTED 0010b854 : #undef rtems_object_id_get_node uint32_t rtems_object_id_get_node( rtems_id id ) { 10b854: 55 push %ebp <== NOT EXECUTED 10b855: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b857: 0f b6 45 0a movzbl 0xa(%ebp),%eax <== NOT EXECUTED return _Objects_Get_node( id ); } 10b85b: c9 leave <== NOT EXECUTED 10b85c: c3 ret <== NOT EXECUTED 0010a684 : */ rtems_status_code rtems_object_set_name( rtems_id id, const char *name ) { 10a684: 55 push %ebp <== NOT EXECUTED 10a685: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a687: 57 push %edi <== NOT EXECUTED 10a688: 56 push %esi <== NOT EXECUTED 10a689: 53 push %ebx <== NOT EXECUTED 10a68a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10a68d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a690: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 10a693: 85 ff test %edi,%edi <== NOT EXECUTED 10a695: 74 65 je 10a6fc <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10a697: 85 c0 test %eax,%eax <== NOT EXECUTED 10a699: 74 45 je 10a6e0 <== NOT EXECUTED 10a69b: 89 c3 mov %eax,%ebx <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 10a69d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a6a0: 53 push %ebx <== NOT EXECUTED 10a6a1: e8 32 19 00 00 call 10bfd8 <_Objects_Get_information_id> <== NOT EXECUTED 10a6a6: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( !information ) 10a6a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a6ab: 85 c0 test %eax,%eax <== NOT EXECUTED 10a6ad: 74 3d je 10a6ec <== NOT EXECUTED return RTEMS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &location ); 10a6af: 50 push %eax <== NOT EXECUTED 10a6b0: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10a6b3: 50 push %eax <== NOT EXECUTED 10a6b4: 53 push %ebx <== NOT EXECUTED 10a6b5: 56 push %esi <== NOT EXECUTED 10a6b6: e8 dd 1a 00 00 call 10c198 <_Objects_Get> <== NOT EXECUTED switch ( location ) { 10a6bb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a6be: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10a6c1: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a6c3: 75 27 jne 10a6ec <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Set_name( information, the_object, name ); 10a6c5: 52 push %edx <== NOT EXECUTED 10a6c6: 57 push %edi <== NOT EXECUTED 10a6c7: 50 push %eax <== NOT EXECUTED 10a6c8: 56 push %esi <== NOT EXECUTED 10a6c9: e8 ae 1c 00 00 call 10c37c <_Objects_Set_name> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a6ce: e8 fd 23 00 00 call 10cad0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a6d3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a6d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a6d8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a6db: 5b pop %ebx <== NOT EXECUTED 10a6dc: 5e pop %esi <== NOT EXECUTED 10a6dd: 5f pop %edi <== NOT EXECUTED 10a6de: c9 leave <== NOT EXECUTED 10a6df: c3 ret <== NOT EXECUTED Objects_Id tmpId; if ( !name ) return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10a6e0: a1 fc 2f 12 00 mov 0x122ffc,%eax <== NOT EXECUTED 10a6e5: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED 10a6e8: eb b3 jmp 10a69d <== NOT EXECUTED 10a6ea: 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; 10a6ec: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a6f1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a6f4: 5b pop %ebx <== NOT EXECUTED 10a6f5: 5e pop %esi <== NOT EXECUTED 10a6f6: 5f pop %edi <== NOT EXECUTED 10a6f7: c9 leave <== NOT EXECUTED 10a6f8: c3 ret <== NOT EXECUTED 10a6f9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 10a6fc: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a701: eb d5 jmp 10a6d8 <== 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 78 6d 13 00 mov 0x136d78,%eax <== NOT EXECUTED 1127e1: 40 inc %eax <== NOT EXECUTED 1127e2: a3 78 6d 13 00 mov %eax,0x136d78 <== 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 80 6b 13 00 push $0x136b80 <== NOT EXECUTED 1127ef: e8 18 3f 00 00 call 11670c <_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 1c 2d 00 00 call 115550 <_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 9c 6b 13 00 mov 0x136b9c,%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 35 4c 00 00 call 117484 <_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 23 4c 00 00 call 117484 <_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 80 6b 13 00 push $0x136b80 <== NOT EXECUTED 11287f: e8 bc 43 00 00 call 116c40 <_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 dc 4b 00 00 call 117484 <_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 80 6b 13 00 push $0x136b80 <== NOT EXECUTED 1128bd: e8 ca 3e 00 00 call 11678c <_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 80 6b 13 00 push $0x136b80 <== NOT EXECUTED 1128ca: e8 fd 41 00 00 call 116acc <_Objects_Free> <== NOT EXECUTED 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 1128cf: e8 b0 4b 00 00 call 117484 <_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 80 6b 13 00 push $0x136b80 <== NOT EXECUTED 1128fd: e8 3e 43 00 00 call 116c40 <_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 0e 2c 00 00 call 115528 <_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 59 4b 00 00 call 117484 <_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 27 4b 00 00 call 117484 <_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 80 6b 13 00 push $0x136b80 <== NOT EXECUTED 112978: e8 1b 44 00 00 call 116d98 <_Objects_Name_to_id_u32> <== NOT EXECUTED 11297d: 8b 04 85 74 b7 12 00 mov 0x12b774(,%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 80 6b 13 00 push $0x136b80 <== NOT EXECUTED 11299b: e8 a0 42 00 00 call 116c40 <_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 bc 4a 00 00 call 117484 <_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 0b 2b 00 00 call 115504 <_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 83 4a 00 00 call 117484 <_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 78 6d 13 00 mov 0x136d78,%eax <== NOT EXECUTED 111df1: 40 inc %eax <== NOT EXECUTED 111df2: a3 78 6d 13 00 mov %eax,0x136d78 <== 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 40 6b 13 00 push $0x136b40 <== NOT EXECUTED 111dff: e8 08 49 00 00 call 11670c <_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 5c 6b 13 00 mov 0x136b5c,%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 49 56 00 00 call 117484 <_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 3b 56 00 00 call 117484 <_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 40 6b 13 00 push $0x136b40 <== NOT EXECUTED 111e63: e8 d8 4d 00 00 call 116c40 <_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 40 6b 13 00 push $0x136b40 <== NOT EXECUTED 111e7d: e8 0a 49 00 00 call 11678c <_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 40 6b 13 00 push $0x136b40 <== NOT EXECUTED 111e8a: e8 3d 4c 00 00 call 116acc <_Objects_Free> <== NOT EXECUTED _Dual_ported_memory_Free( the_port ); _Thread_Enable_dispatch(); 111e8f: e8 f0 55 00 00 call 117484 <_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 40 6b 13 00 push $0x136b40 <== NOT EXECUTED 111ec7: e8 74 4d 00 00 call 116c40 <_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 99 55 00 00 call 117484 <_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 40 6b 13 00 push $0x136b40 <== NOT EXECUTED 111f27: e8 6c 4e 00 00 call 116d98 <_Objects_Name_to_id_u32> <== NOT EXECUTED 111f2c: 8b 04 85 74 b7 12 00 mov 0x12b774(,%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 40 6b 13 00 push $0x136b40 <== NOT EXECUTED 111f53: e8 e8 4c 00 00 call 116c40 <_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 0d 55 00 00 call 117484 <_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 c0 6b 13 00 push $0x136bc0 <== NOT EXECUTED 112a1f: e8 1c 42 00 00 call 116c40 <_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 3c 6e 13 00 cmp 0x136e3c,%eax <== NOT EXECUTED 112a45: 74 11 je 112a58 <== NOT EXECUTED _Thread_Enable_dispatch(); 112a47: e8 38 4a 00 00 call 117484 <_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 18 5e 00 00 call 11887c <_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 14 4a 00 00 call 117484 <_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 58 3f 12 00 mov 0x123f58,%eax <== NOT EXECUTED 10afbc: 40 inc %eax <== NOT EXECUTED 10afbd: a3 58 3f 12 00 mov %eax,0x123f58 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 10afc2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10afc5: 68 60 3e 12 00 push $0x123e60 <== NOT EXECUTED 10afca: e8 7d 1e 00 00 call 10ce4c <_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 1c 40 12 00 mov 0x12401c,%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 7c 3e 12 00 mov 0x123e7c,%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 3a 2c 00 00 call 10dc84 <_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 1b 2c 00 00 call 10dc84 <_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 c0 6b 13 00 push $0x136bc0 <== NOT EXECUTED 112b7b: e8 c0 40 00 00 call 116c40 <_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 c0 6b 13 00 push $0x136bc0 <== NOT EXECUTED 112b95: e8 f2 3b 00 00 call 11678c <_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 d7 5c 00 00 call 11887c <_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 c0 6b 13 00 push $0x136bc0 <== NOT EXECUTED 112bb4: e8 13 3f 00 00 call 116acc <_Objects_Free> <== NOT EXECUTED _Rate_monotonic_Free( the_period ); _Thread_Enable_dispatch(); 112bb9: e8 c6 48 00 00 call 117484 <_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 0012ff24 : rtems_status_code rtems_rate_monotonic_get_statistics( Objects_Id id, rtems_rate_monotonic_period_statistics *statistics ) { 12ff24: 55 push %ebp <== NOT EXECUTED 12ff25: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12ff27: 57 push %edi <== NOT EXECUTED 12ff28: 56 push %esi <== NOT EXECUTED 12ff29: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 12ff2c: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 12ff2f: 85 ff test %edi,%edi <== NOT EXECUTED 12ff31: 74 41 je 12ff74 <== 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 12ff33: 51 push %ecx <== NOT EXECUTED 12ff34: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 12ff37: 50 push %eax <== NOT EXECUTED 12ff38: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12ff3b: 68 e0 2b 16 00 push $0x162be0 <== NOT EXECUTED 12ff40: e8 3f 0f fe ff call 110e84 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 12ff45: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12ff48: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 12ff4b: 85 d2 test %edx,%edx <== NOT EXECUTED 12ff4d: 74 0d je 12ff5c <== NOT EXECUTED 12ff4f: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12ff54: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12ff57: 5e pop %esi <== NOT EXECUTED 12ff58: 5f pop %edi <== NOT EXECUTED 12ff59: c9 leave <== NOT EXECUTED 12ff5a: c3 ret <== NOT EXECUTED 12ff5b: 90 nop <== NOT EXECUTED the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: *statistics = the_period->Statistics; 12ff5c: 8d 70 54 lea 0x54(%eax),%esi <== NOT EXECUTED 12ff5f: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 12ff64: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 12ff66: e8 0d 18 fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 12ff6b: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12ff6d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12ff70: 5e pop %esi <== NOT EXECUTED 12ff71: 5f pop %edi <== NOT EXECUTED 12ff72: c9 leave <== NOT EXECUTED 12ff73: c3 ret <== NOT EXECUTED ) { Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 12ff74: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12ff79: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12ff7c: 5e pop %esi <== NOT EXECUTED 12ff7d: 5f pop %edi <== NOT EXECUTED 12ff7e: c9 leave <== NOT EXECUTED 12ff7f: c3 ret <== NOT EXECUTED 0012ff80 : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 12ff80: 55 push %ebp <== NOT EXECUTED 12ff81: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12ff83: 57 push %edi <== NOT EXECUTED 12ff84: 56 push %esi <== NOT EXECUTED 12ff85: 53 push %ebx <== NOT EXECUTED 12ff86: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 12ff89: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 12ff8c: 85 f6 test %esi,%esi <== NOT EXECUTED 12ff8e: 74 70 je 130000 <== NOT EXECUTED 12ff90: 52 push %edx <== NOT EXECUTED 12ff91: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 12ff94: 50 push %eax <== NOT EXECUTED 12ff95: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12ff98: 68 e0 2b 16 00 push $0x162be0 <== NOT EXECUTED 12ff9d: e8 e2 0e fe ff call 110e84 <_Objects_Get> <== NOT EXECUTED 12ffa2: 89 c7 mov %eax,%edi <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 12ffa4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12ffa7: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 12ffaa: 85 c0 test %eax,%eax <== NOT EXECUTED 12ffac: 75 42 jne 12fff0 <== NOT EXECUTED case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 12ffae: 8b 47 50 mov 0x50(%edi),%eax <== NOT EXECUTED 12ffb1: 85 c0 test %eax,%eax <== NOT EXECUTED 12ffb3: 74 03 je 12ffb8 <== NOT EXECUTED 12ffb5: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 12ffb8: 89 06 mov %eax,(%esi) <== NOT EXECUTED status->state = the_period->state; 12ffba: 8b 47 38 mov 0x38(%edi),%eax <== NOT EXECUTED 12ffbd: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED if ( status->state == RATE_MONOTONIC_INACTIVE ) { 12ffc0: 85 c0 test %eax,%eax <== NOT EXECUTED 12ffc2: 75 4c jne 130010 <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS status->since_last_period.tv_sec = 0; 12ffc4: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) <== NOT EXECUTED status->since_last_period.tv_nsec = 0; 12ffcb: 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; 12ffd2: c7 46 10 00 00 00 00 movl $0x0,0x10(%esi) <== NOT EXECUTED status->executed_since_last_period.tv_nsec = 0; 12ffd9: 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(); 12ffe0: e8 93 17 fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 12ffe5: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12ffe7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12ffea: 5b pop %ebx <== NOT EXECUTED 12ffeb: 5e pop %esi <== NOT EXECUTED 12ffec: 5f pop %edi <== NOT EXECUTED 12ffed: c9 leave <== NOT EXECUTED 12ffee: c3 ret <== NOT EXECUTED 12ffef: 90 nop <== NOT EXECUTED if ( !status ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 12fff0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12fff5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12fff8: 5b pop %ebx <== NOT EXECUTED 12fff9: 5e pop %esi <== NOT EXECUTED 12fffa: 5f pop %edi <== NOT EXECUTED 12fffb: c9 leave <== NOT EXECUTED 12fffc: c3 ret <== NOT EXECUTED 12fffd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 130000: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 130005: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 130008: 5b pop %ebx <== NOT EXECUTED 130009: 5e pop %esi <== NOT EXECUTED 13000a: 5f pop %edi <== NOT EXECUTED 13000b: c9 leave <== NOT EXECUTED 13000c: c3 ret <== NOT EXECUTED 13000d: 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 ); 130010: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 130013: 8d 5d e8 lea -0x18(%ebp),%ebx <== NOT EXECUTED 130016: 53 push %ebx <== NOT EXECUTED 130017: e8 64 6d ff ff call 126d80 <_TOD_Get_uptime> <== NOT EXECUTED #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 13001c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 13001f: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED 130022: 50 push %eax <== NOT EXECUTED 130023: 53 push %ebx <== NOT EXECUTED 130024: 8d 47 44 lea 0x44(%edi),%eax <== NOT EXECUTED 130027: 50 push %eax <== NOT EXECUTED 130028: e8 b3 23 fe ff call 1123e0 <_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( 13002d: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 130030: 8d 46 10 lea 0x10(%esi),%eax <== NOT EXECUTED 130033: 50 push %eax <== NOT EXECUTED 130034: 53 push %ebx <== NOT EXECUTED 130035: 68 c4 1f 16 00 push $0x161fc4 <== NOT EXECUTED 13003a: e8 a1 23 fe ff call 1123e0 <_Timespec_Subtract> <== NOT EXECUTED 13003f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 130042: eb 9c jmp 12ffe0 <== 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 60 3e 12 00 push $0x123e60 <== NOT EXECUTED 10b09e: e8 f5 24 00 00 call 10d598 <_Objects_Name_to_id_u32> <== NOT EXECUTED 10b0a3: 8b 04 85 74 cc 11 00 mov 0x11cc74(,%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 60 3e 12 00 push $0x123e60 <== NOT EXECUTED 10b286: e8 b5 21 00 00 call 10d440 <_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 1c 40 12 00 cmp 0x12401c,%eax <== NOT EXECUTED 10b2b1: 74 15 je 10b2c8 <== NOT EXECUTED _Thread_Enable_dispatch(); 10b2b3: e8 cc 29 00 00 call 10dc84 <_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 3c 40 12 00 push $0x12403c <== NOT EXECUTED 10b329: e8 2a 3a 00 00 call 10ed58 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 10b32e: e8 51 29 00 00 call 10dc84 <_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 1c 40 12 00 mov 0x12401c,%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 f3 31 00 00 call 10e564 <_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 f7 28 00 00 call 10dc84 <_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 df 28 00 00 call 10dc84 <_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 3c 40 12 00 push $0x12403c <== NOT EXECUTED 10b3d2: e8 81 39 00 00 call 10ed58 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 10b3d7: e8 a8 28 00 00 call 10dc84 <_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 1c 40 12 00 pushl 0x12401c <== NOT EXECUTED 10b407: e8 d0 24 00 00 call 10d8dc <_Thread_Clear_state> <== NOT EXECUTED 10b40c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b40f: e9 74 ff ff ff jmp 10b388 <== NOT EXECUTED 00126320 : } } } void rtems_rate_monotonic_report_statistics( void ) { 126320: 55 push %ebp <== NOT EXECUTED 126321: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126323: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin ); 126326: 68 8c c7 10 00 push $0x10c78c <== NOT EXECUTED 12632b: 6a 00 push $0x0 <== NOT EXECUTED 12632d: e8 de fd ff ff call 126110 <== NOT EXECUTED 126332: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 126335: c9 leave <== NOT EXECUTED 126336: c3 ret <== NOT EXECUTED 00126110 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 126110: 55 push %ebp <== NOT EXECUTED 126111: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126113: 57 push %edi <== NOT EXECUTED 126114: 56 push %esi <== NOT EXECUTED 126115: 53 push %ebx <== NOT EXECUTED 126116: 81 ec 9c 00 00 00 sub $0x9c,%esp <== NOT EXECUTED 12611c: 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 ) 12611f: 85 ff test %edi,%edi <== NOT EXECUTED 126121: 0f 84 c9 00 00 00 je 1261f0 <== NOT EXECUTED return; (*print)( context, "Period information by period\n" ); 126127: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12612a: 68 78 53 14 00 push $0x145378 <== NOT EXECUTED 12612f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 126132: ff d7 call *%edi <== NOT EXECUTED #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 126134: 5e pop %esi <== NOT EXECUTED 126135: 58 pop %eax <== NOT EXECUTED 126136: 68 b0 53 14 00 push $0x1453b0 <== NOT EXECUTED 12613b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12613e: ff d7 call *%edi <== NOT EXECUTED #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 126140: 59 pop %ecx <== NOT EXECUTED 126141: 5b pop %ebx <== NOT EXECUTED 126142: 68 d4 53 14 00 push $0x1453d4 <== NOT EXECUTED 126147: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12614a: ff d7 call *%edi <== NOT EXECUTED Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 12614c: 58 pop %eax <== NOT EXECUTED 12614d: 5a pop %edx <== NOT EXECUTED 12614e: 68 f8 53 14 00 push $0x1453f8 <== NOT EXECUTED 126153: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 126156: ff d7 call *%edi <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 126158: 5b pop %ebx <== NOT EXECUTED 126159: 5e pop %esi <== NOT EXECUTED 12615a: 68 44 54 14 00 push $0x145444 <== NOT EXECUTED 12615f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 126162: 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 ; 126164: 8b 35 e8 2b 16 00 mov 0x162be8,%esi <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; 12616a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12616d: 3b 35 ec 2b 16 00 cmp 0x162bec,%esi <== NOT EXECUTED 126173: 76 0c jbe 126181 <== NOT EXECUTED 126175: eb 79 jmp 1261f0 <== NOT EXECUTED 126177: 90 nop <== NOT EXECUTED id++ ) { 126178: 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 ; 126179: 39 35 ec 2b 16 00 cmp %esi,0x162bec <== NOT EXECUTED 12617f: 72 6f jb 1261f0 <== NOT EXECUTED id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 126181: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 126184: 8d 45 90 lea -0x70(%ebp),%eax <== NOT EXECUTED 126187: 50 push %eax <== NOT EXECUTED 126188: 56 push %esi <== NOT EXECUTED 126189: e8 96 9d 00 00 call 12ff24 <== NOT EXECUTED if ( status != RTEMS_SUCCESSFUL ) 12618e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126191: 85 c0 test %eax,%eax <== NOT EXECUTED 126193: 75 e3 jne 126178 <== NOT EXECUTED continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 126195: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 126198: 8d 55 c8 lea -0x38(%ebp),%edx <== NOT EXECUTED 12619b: 52 push %edx <== NOT EXECUTED 12619c: 56 push %esi <== NOT EXECUTED 12619d: e8 de 9d 00 00 call 12ff80 <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( status != RTEMS_SUCCESSFUL ) continue; #endif name[ 0 ] = '\0'; 1261a2: c6 45 eb 00 movb $0x0,-0x15(%ebp) <== NOT EXECUTED if ( the_status.owner ) { 1261a6: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 1261a9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1261ac: 85 c0 test %eax,%eax <== NOT EXECUTED 1261ae: 0f 85 54 01 00 00 jne 126308 <== NOT EXECUTED 1261b4: 8d 5d eb lea -0x15(%ebp),%ebx <== NOT EXECUTED /* * Print part of report line that is not dependent on granularity */ (*print)( context, 1261b7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1261ba: ff 75 94 pushl -0x6c(%ebp) <== NOT EXECUTED 1261bd: ff 75 90 pushl -0x70(%ebp) <== NOT EXECUTED 1261c0: 53 push %ebx <== NOT EXECUTED 1261c1: 56 push %esi <== NOT EXECUTED 1261c2: 68 96 53 14 00 push $0x145396 <== NOT EXECUTED 1261c7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1261ca: ff d7 call *%edi <== NOT EXECUTED /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 1261cc: 8b 45 90 mov -0x70(%ebp),%eax <== NOT EXECUTED 1261cf: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1261d2: 85 c0 test %eax,%eax <== NOT EXECUTED 1261d4: 75 22 jne 1261f8 <== NOT EXECUTED (*print)( context, "\n" ); 1261d6: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1261d9: 68 68 57 14 00 push $0x145768 <== NOT EXECUTED 1261de: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1261e1: ff d7 call *%edi <== NOT EXECUTED 1261e3: 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++ ) { 1261e6: 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 ; 1261e7: 39 35 ec 2b 16 00 cmp %esi,0x162bec <== NOT EXECUTED 1261ed: 73 92 jae 126181 <== NOT EXECUTED 1261ef: 90 nop <== NOT EXECUTED the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 1261f0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1261f3: 5b pop %ebx <== NOT EXECUTED 1261f4: 5e pop %esi <== NOT EXECUTED 1261f5: 5f pop %edi <== NOT EXECUTED 1261f6: c9 leave <== NOT EXECUTED 1261f7: c3 ret <== NOT EXECUTED */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 1261f8: 52 push %edx <== NOT EXECUTED 1261f9: 8d 55 e0 lea -0x20(%ebp),%edx <== NOT EXECUTED 1261fc: 52 push %edx <== NOT EXECUTED 1261fd: 50 push %eax <== NOT EXECUTED 1261fe: 8d 45 a8 lea -0x58(%ebp),%eax <== NOT EXECUTED 126201: 50 push %eax <== NOT EXECUTED 126202: e8 1d 15 00 00 call 127724 <_Timespec_Divide_by_integer> <== NOT EXECUTED &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 126207: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 12620a: bb d3 4d 62 10 mov $0x10624dd3,%ebx <== NOT EXECUTED 12620f: 89 c8 mov %ecx,%eax <== NOT EXECUTED 126211: f7 eb imul %ebx <== NOT EXECUTED 126213: 89 45 88 mov %eax,-0x78(%ebp) <== NOT EXECUTED 126216: 89 55 8c mov %edx,-0x74(%ebp) <== NOT EXECUTED 126219: 8b 45 8c mov -0x74(%ebp),%eax <== NOT EXECUTED 12621c: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 12621f: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 126222: 29 c8 sub %ecx,%eax <== NOT EXECUTED 126224: 50 push %eax <== NOT EXECUTED 126225: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 126228: 8b 4d a4 mov -0x5c(%ebp),%ecx <== NOT EXECUTED 12622b: 89 c8 mov %ecx,%eax <== NOT EXECUTED 12622d: f7 eb imul %ebx <== NOT EXECUTED 12622f: 89 45 80 mov %eax,-0x80(%ebp) <== NOT EXECUTED 126232: 89 55 84 mov %edx,-0x7c(%ebp) <== NOT EXECUTED 126235: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 126238: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 12623b: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 12623e: 29 c8 sub %ecx,%eax <== NOT EXECUTED 126240: 50 push %eax <== NOT EXECUTED 126241: ff 75 a0 pushl -0x60(%ebp) <== NOT EXECUTED 126244: 8b 4d 9c mov -0x64(%ebp),%ecx <== NOT EXECUTED 126247: 89 c8 mov %ecx,%eax <== NOT EXECUTED 126249: f7 eb imul %ebx <== NOT EXECUTED 12624b: 89 85 78 ff ff ff mov %eax,-0x88(%ebp) <== NOT EXECUTED 126251: 89 95 7c ff ff ff mov %edx,-0x84(%ebp) <== NOT EXECUTED 126257: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax <== NOT EXECUTED 12625d: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 126260: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 126263: 29 c8 sub %ecx,%eax <== NOT EXECUTED 126265: 50 push %eax <== NOT EXECUTED 126266: ff 75 98 pushl -0x68(%ebp) <== NOT EXECUTED 126269: 68 90 54 14 00 push $0x145490 <== NOT EXECUTED 12626e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 126271: 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( 126273: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED 126276: 8d 55 e0 lea -0x20(%ebp),%edx <== NOT EXECUTED 126279: 52 push %edx <== NOT EXECUTED 12627a: ff 75 90 pushl -0x70(%ebp) <== NOT EXECUTED 12627d: 8d 45 c0 lea -0x40(%ebp),%eax <== NOT EXECUTED 126280: 50 push %eax <== NOT EXECUTED 126281: e8 9e 14 00 00 call 127724 <_Timespec_Divide_by_integer> <== NOT EXECUTED &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 126286: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 126289: 89 c8 mov %ecx,%eax <== NOT EXECUTED 12628b: f7 eb imul %ebx <== NOT EXECUTED 12628d: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) <== NOT EXECUTED 126293: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) <== NOT EXECUTED 126299: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax <== NOT EXECUTED 12629f: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 1262a2: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 1262a5: 29 c8 sub %ecx,%eax <== NOT EXECUTED 1262a7: 50 push %eax <== NOT EXECUTED 1262a8: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 1262ab: 8b 4d bc mov -0x44(%ebp),%ecx <== NOT EXECUTED 1262ae: 89 c8 mov %ecx,%eax <== NOT EXECUTED 1262b0: f7 eb imul %ebx <== NOT EXECUTED 1262b2: 89 85 68 ff ff ff mov %eax,-0x98(%ebp) <== NOT EXECUTED 1262b8: 89 95 6c ff ff ff mov %edx,-0x94(%ebp) <== NOT EXECUTED 1262be: 8b 85 6c ff ff ff mov -0x94(%ebp),%eax <== NOT EXECUTED 1262c4: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 1262c7: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 1262ca: 29 c8 sub %ecx,%eax <== NOT EXECUTED 1262cc: 50 push %eax <== NOT EXECUTED 1262cd: ff 75 b8 pushl -0x48(%ebp) <== NOT EXECUTED 1262d0: 8b 4d b4 mov -0x4c(%ebp),%ecx <== NOT EXECUTED 1262d3: 89 c8 mov %ecx,%eax <== NOT EXECUTED 1262d5: f7 eb imul %ebx <== NOT EXECUTED 1262d7: 89 85 60 ff ff ff mov %eax,-0xa0(%ebp) <== NOT EXECUTED 1262dd: 89 95 64 ff ff ff mov %edx,-0x9c(%ebp) <== NOT EXECUTED 1262e3: 8b 85 64 ff ff ff mov -0x9c(%ebp),%eax <== NOT EXECUTED 1262e9: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 1262ec: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 1262ef: 29 c8 sub %ecx,%eax <== NOT EXECUTED 1262f1: 50 push %eax <== NOT EXECUTED 1262f2: ff 75 b0 pushl -0x50(%ebp) <== NOT EXECUTED 1262f5: 68 b0 54 14 00 push $0x1454b0 <== NOT EXECUTED 1262fa: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1262fd: ff d7 call *%edi <== NOT EXECUTED 1262ff: 83 c4 30 add $0x30,%esp <== NOT EXECUTED 126302: e9 71 fe ff ff jmp 126178 <== NOT EXECUTED 126307: 90 nop <== NOT EXECUTED #endif name[ 0 ] = '\0'; if ( the_status.owner ) { rtems_object_get_name( the_status.owner, sizeof(name), name ); 126308: 51 push %ecx <== NOT EXECUTED 126309: 8d 5d eb lea -0x15(%ebp),%ebx <== NOT EXECUTED 12630c: 53 push %ebx <== NOT EXECUTED 12630d: 6a 05 push $0x5 <== NOT EXECUTED 12630f: 50 push %eax <== NOT EXECUTED 126310: e8 f3 8d fe ff call 10f108 <== NOT EXECUTED 126315: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126318: e9 9a fe ff ff jmp 1261b7 <== NOT EXECUTED 00126338 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 126338: 55 push %ebp <== NOT EXECUTED 126339: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12633b: 53 push %ebx <== NOT EXECUTED 12633c: 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 12633f: a1 f8 1e 16 00 mov 0x161ef8,%eax <== NOT EXECUTED 126344: 40 inc %eax <== NOT EXECUTED 126345: a3 f8 1e 16 00 mov %eax,0x161ef8 <== 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 ; 12634a: 8b 1d e8 2b 16 00 mov 0x162be8,%ebx <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; 126350: 3b 1d ec 2b 16 00 cmp 0x162bec,%ebx <== NOT EXECUTED 126356: 77 15 ja 12636d <== NOT EXECUTED id++ ) { status = rtems_rate_monotonic_reset_statistics( id ); 126358: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12635b: 53 push %ebx <== NOT EXECUTED 12635c: e8 17 00 00 00 call 126378 <== 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++ ) { 126361: 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 ; 126362: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126365: 39 1d ec 2b 16 00 cmp %ebx,0x162bec <== NOT EXECUTED 12636b: 73 eb jae 126358 <== NOT EXECUTED /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); } 12636d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 126370: c9 leave <== NOT EXECUTED } /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); 126371: e9 02 b4 fe ff jmp 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 00126378 : */ rtems_status_code rtems_rate_monotonic_reset_statistics( Objects_Id id ) { 126378: 55 push %ebp <== NOT EXECUTED 126379: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12637b: 57 push %edi <== NOT EXECUTED 12637c: 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 12637f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 126382: 50 push %eax <== NOT EXECUTED 126383: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 126386: 68 e0 2b 16 00 push $0x162be0 <== NOT EXECUTED 12638b: e8 f4 aa fe ff call 110e84 <_Objects_Get> <== NOT EXECUTED 126390: 89 c2 mov %eax,%edx <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 126392: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126395: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 126398: 85 c0 test %eax,%eax <== NOT EXECUTED 12639a: 75 34 jne 1263d0 <== NOT EXECUTED case OBJECTS_LOCAL: _Rate_monotonic_Reset_statistics( the_period ); 12639c: 8d 7a 54 lea 0x54(%edx),%edi <== NOT EXECUTED 12639f: b9 38 00 00 00 mov $0x38,%ecx <== NOT EXECUTED 1263a4: 31 c0 xor %eax,%eax <== NOT EXECUTED 1263a6: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 1263a8: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx) <== NOT EXECUTED 1263af: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx) <== NOT EXECUTED 1263b6: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx) <== NOT EXECUTED 1263bd: c7 42 78 ff ff ff 7f movl $0x7fffffff,0x78(%edx) <== NOT EXECUTED _Thread_Enable_dispatch(); 1263c4: e8 af b3 fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 1263c9: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1263cb: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 1263ce: c9 leave <== NOT EXECUTED 1263cf: c3 ret <== NOT EXECUTED { Objects_Locations location; Rate_monotonic_Control *the_period; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 1263d0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1263d5: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 1263d8: c9 leave <== NOT EXECUTED 1263d9: 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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113109: e8 82 23 00 00 call 115490 <_API_Mutex_Lock> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 11310e: c7 04 24 00 6c 13 00 movl $0x136c00,(%esp) <== NOT EXECUTED 113115: e8 f2 35 00 00 call 11670c <_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 01 31 00 00 call 116238 <_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 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 11314a: e8 7d 39 00 00 call 116acc <_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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113160: e8 73 23 00 00 call 1154d8 <_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 14 4a 00 00 call 117bb8 <_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 1c 6c 13 00 mov 0x136c1c,%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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 1131d5: e8 b6 22 00 00 call 115490 <_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 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 1131e9: e8 12 3a 00 00 call 116c00 <_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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113219: e8 ba 22 00 00 call 1154d8 <_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 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 113239: e8 4e 35 00 00 call 11678c <_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 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 113246: e8 81 38 00 00 call 116acc <_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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 11326c: e8 1f 22 00 00 call 115490 <_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 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 113280: e8 7b 39 00 00 call 116c00 <_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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 1132a2: e8 31 22 00 00 call 1154d8 <_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 9b 2c 00 00 call 115f60 <_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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 11331f: e8 6c 21 00 00 call 115490 <_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 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 113333: e8 c8 38 00 00 call 116c00 <_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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113353: e8 80 21 00 00 call 1154d8 <_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 de 2d 00 00 call 116164 <_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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 1133bb: e8 d0 20 00 00 call 115490 <_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 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 1133cf: e8 2c 38 00 00 call 116c00 <_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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 1133ef: e8 e4 20 00 00 call 1154d8 <_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 9f 2d 00 00 call 1161ac <_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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113469: e8 22 20 00 00 call 115490 <_API_Mutex_Lock> <== NOT EXECUTED executing = _Thread_Executing; 11346e: a1 3c 6e 13 00 mov 0x136e3c,%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 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 113485: e8 76 37 00 00 call 116c00 <_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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 1134a7: e8 2c 20 00 00 call 1154d8 <_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 eb 29 00 00 call 115ecc <_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 78 6d 13 00 mov 0x136d78,%eax <== NOT EXECUTED 113503: 40 inc %eax <== NOT EXECUTED 113504: a3 78 6d 13 00 mov %eax,0x136d78 <== 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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113512: e8 c1 1f 00 00 call 1154d8 <_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 94 7c 11 00 push $0x117c94 <== NOT EXECUTED 11353b: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 11353e: 50 push %eax <== NOT EXECUTED 11353f: e8 00 44 00 00 call 117944 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 113544: e8 3b 3f 00 00 call 117484 <_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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113577: e8 14 1f 00 00 call 115490 <_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 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 11358b: e8 70 36 00 00 call 116c00 <_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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 1135ab: e8 28 1f 00 00 call 1154d8 <_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 44 30 00 00 call 11660c <_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 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 113602: e8 91 37 00 00 call 116d98 <_Objects_Name_to_id_u32> <== NOT EXECUTED 113607: 8b 04 85 74 b7 12 00 mov 0x12b774(,%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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 11362d: e8 5e 1e 00 00 call 115490 <_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 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 113641: e8 ba 35 00 00 call 116c00 <_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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113667: e8 6c 1e 00 00 call 1154d8 <_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 8a 2d 00 00 call 116420 <_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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 1136b4: e8 1f 1e 00 00 call 1154d8 <_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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 1136d1: e8 02 1e 00 00 call 1154d8 <_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 23 72 00 00 call 11a928 <_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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113725: e8 66 1d 00 00 call 115490 <_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 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 113739: e8 c2 34 00 00 call 116c00 <_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 ab 28 00 00 call 116004 <_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 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113779: e8 5a 1d 00 00 call 1154d8 <_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 8c 71 00 00 call 11a928 <_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 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10a1b5: 40 inc %eax <== NOT EXECUTED 10a1b6: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 10a1bb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a1be: 68 00 f7 11 00 push $0x11f700 <== NOT EXECUTED 10a1c3: e8 4c 14 00 00 call 10b614 <_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 44 0d 00 00 call 10af64 <_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 00 f7 11 00 push $0x11f700 <== NOT EXECUTED 10a231: e8 9e 17 00 00 call 10b9d4 <_Objects_Free> <== NOT EXECUTED _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 10a236: e8 11 21 00 00 call 10c34c <_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 96 0f 00 00 call 10b21c <_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 1c f7 11 00 mov 0x11f71c,%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 a8 20 00 00 call 10c34c <_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 87 20 00 00 call 10c34c <_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 00 f7 11 00 push $0x11f700 <== NOT EXECUTED 10a31b: e8 e8 17 00 00 call 10bb08 <_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 fb 1f 00 00 call 10c34c <_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 ee 0b 00 00 call 10af58 <_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 00 f7 11 00 push $0x11f700 <== NOT EXECUTED 10a376: e8 19 13 00 00 call 10b694 <_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 00 f7 11 00 push $0x11f700 <== NOT EXECUTED 10a383: e8 4c 16 00 00 call 10b9d4 <_Objects_Free> <== NOT EXECUTED 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 10a388: e8 bf 1f 00 00 call 10c34c <_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 6a 0e 00 00 call 10b210 <_CORE_semaphore_Flush> <== NOT EXECUTED 10a3a6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a3a9: eb c2 jmp 10a36d <== NOT EXECUTED 0012643c : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 12643c: 55 push %ebp <== NOT EXECUTED 12643d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12643f: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED * to add to the heap 126442: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 126445: 50 push %eax <== NOT EXECUTED 126446: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 126449: 68 40 1e 16 00 push $0x161e40 <== NOT EXECUTED 12644e: e8 31 aa fe ff call 110e84 <_Objects_Get> <== NOT EXECUTED register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 126453: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126456: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 126459: 85 d2 test %edx,%edx <== NOT EXECUTED 12645b: 74 07 je 126464 <== NOT EXECUTED 12645d: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126462: c9 leave <== NOT EXECUTED 126463: c3 ret <== NOT EXECUTED the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 126464: f6 40 10 30 testb $0x30,0x10(%eax) <== NOT EXECUTED 126468: 75 1a jne 126484 <== NOT EXECUTED &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 12646a: 52 push %edx <== NOT EXECUTED 12646b: 6a 01 push $0x1 <== NOT EXECUTED 12646d: 6a 00 push $0x0 <== NOT EXECUTED 12646f: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 126472: 50 push %eax <== NOT EXECUTED 126473: e8 b4 9f fe ff call 11042c <_CORE_semaphore_Flush> <== NOT EXECUTED 126478: 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(); 12647b: e8 f8 b2 fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 126480: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126482: c9 leave <== NOT EXECUTED 126483: 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( 126484: 51 push %ecx <== NOT EXECUTED 126485: 6a 01 push $0x1 <== NOT EXECUTED 126487: 6a 00 push $0x0 <== NOT EXECUTED 126489: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 12648c: 50 push %eax <== NOT EXECUTED 12648d: e8 e2 9c fe ff call 110174 <_CORE_mutex_Flush> <== NOT EXECUTED 126492: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126495: eb e4 jmp 12647b <== 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 40 6c 13 00 push $0x136c40 <== NOT EXECUTED 113a94: e8 ff 32 00 00 call 116d98 <_Objects_Name_to_id_u32> <== NOT EXECUTED 113a99: 8b 04 85 74 b7 12 00 mov 0x12b774(,%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 00 f7 11 00 push $0x11f700 <== NOT EXECUTED 10a3c5: e8 f2 16 00 00 call 10babc <_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 54 0c 00 00 call 10b05c <_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 7c f8 11 00 mov 0x11f87c,%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 7c f8 11 00 mov 0x11f87c,%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 7c f8 11 00 mov 0x11f87c,%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 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10a471: 40 inc %eax <== NOT EXECUTED 10a472: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== 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 5c cb 10 00 push $0x10cb5c <== NOT EXECUTED 10a48f: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10a492: 50 push %eax <== NOT EXECUTED 10a493: e8 74 23 00 00 call 10c80c <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED size_t size, 10a498: e8 af 1e 00 00 call 10c34c <_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 00 f7 11 00 push $0x11f700 <== NOT EXECUTED 10a4b8: e8 4b 16 00 00 call 10bb08 <_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 75 0d 00 00 call 10b25c <_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 5e 1e 00 00 call 10c34c <_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 eb 0b 00 00 call 10b0f8 <_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 38 1e 00 00 call 10c34c <_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 001172e8 : */ void rtems_shutdown_executive( uint32_t result ) { 1172e8: 55 push %ebp <== NOT EXECUTED 1172e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1172eb: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 1172ee: 83 3d 84 f9 11 00 04 cmpl $0x4,0x11f984 <== NOT EXECUTED 1172f5: 74 1e je 117315 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 1172f7: c7 05 84 f9 11 00 04 movl $0x4,0x11f984 <== NOT EXECUTED 1172fe: 00 00 00 <== NOT EXECUTED #endif } /** * This routine sets the current system state to that specified by * the called. 117301: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 117304: 68 a0 f7 11 00 push $0x11f7a0 <== NOT EXECUTED 117309: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 11730c: 50 push %eax <== NOT EXECUTED 11730d: e8 0e 62 ff ff call 10d520 <_CPU_Context_switch> <== NOT EXECUTED 117312: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_SHUTDOWN ); _Thread_Stop_multitasking(); } } 117315: c9 leave <== NOT EXECUTED 117316: 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 34 12 00 mov 0x12349c,%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 33 12 00 mov 0x1233d8,%eax <== NOT EXECUTED 10b1f9: 40 inc %eax <== NOT EXECUTED 10b1fa: a3 d8 33 12 00 mov %eax,0x1233d8 <== 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 af 21 00 00 call 10d3c0 <_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 7c 21 00 00 call 10d3c0 <_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 45 38 00 00 call 1174a8 <_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 18 6e 13 00 mov 0x136e18,%eax <== NOT EXECUTED 113ca0: 85 c0 test %eax,%eax <== NOT EXECUTED 113ca2: 74 1c je 113cc0 <== NOT EXECUTED 113ca4: 3b 0d 3c 6e 13 00 cmp 0x136e3c,%ecx <== NOT EXECUTED 113caa: 75 14 jne 113cc0 <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 113cac: c6 05 e8 6e 13 00 01 movb $0x1,0x136ee8 <== 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 bf 37 00 00 call 117484 <_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 b3 37 00 00 call 117484 <_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 d4 b1 11 00 movzbl 0x11b1d4,%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 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10a58f: e8 d4 07 00 00 call 10ad68 <_API_Mutex_Lock> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 10a594: c7 04 24 40 f7 11 00 movl $0x11f740,(%esp) <== NOT EXECUTED 10a59b: e8 74 10 00 00 call 10b614 <_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 40 f7 11 00 push $0x11f740 <== NOT EXECUTED 10a5e1: e8 0a 1e 00 00 call 10c3f0 <_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 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10a615: e8 96 07 00 00 call 10adb0 <_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 05 14 00 00 call 10ba48 <_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 88 13 00 00 call 10b9d4 <_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 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10a653: e8 58 07 00 00 call 10adb0 <_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 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10a681: e8 2a 07 00 00 call 10adb0 <_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 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10a6a5: e8 be 06 00 00 call 10ad68 <_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 b8 1c 00 00 call 10c370 <_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 79 13 00 00 call 10ba48 <_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 58 19 00 00 call 10c030 <_Thread_Close> <== NOT EXECUTED 10a6d8: 58 pop %eax <== NOT EXECUTED 10a6d9: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10a6dc: e8 67 13 00 00 call 10ba48 <_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 ea 12 00 00 call 10b9d4 <_Objects_Free> <== NOT EXECUTED _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 10a6ea: 58 pop %eax <== NOT EXECUTED 10a6eb: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10a6f1: e8 ba 06 00 00 call 10adb0 <_API_Mutex_Unlock> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a6f6: e8 51 1c 00 00 call 10c34c <_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 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10a711: e8 9a 06 00 00 call 10adb0 <_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 4b 12 00 mov 0x124bb4,%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 4b 12 00 mov 0x124bdc,%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 8c 1f 00 00 call 10ddc4 <_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 47 1f 00 00 call 10dda0 <_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 4b 12 00 mov 0x124bdc,%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 7c f8 11 00 mov 0x11f87c,%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 40 f7 11 00 push $0x11f740 <== NOT EXECUTED 10a752: e8 09 15 00 00 call 10bc60 <_Objects_Name_to_id_u32> <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; 10a757: 8b 04 85 d4 90 11 00 mov 0x1190d4(,%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 8e 1c 00 00 call 10c978 <_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 4d 1c 00 00 call 10c954 <_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 3f 1c 00 00 call 10c954 <_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 0011078c : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 11078c: 55 push %ebp <== NOT EXECUTED 11078d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11078f: 57 push %edi <== NOT EXECUTED 110790: 56 push %esi <== NOT EXECUTED 110791: 53 push %ebx <== NOT EXECUTED 110792: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110795: 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 ) 110798: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 11079b: 85 c9 test %ecx,%ecx <== NOT EXECUTED 11079d: 0f 84 31 01 00 00 je 1108d4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 1107a3: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED 1107a8: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED api = executing->API_Extensions[ THREAD_API_RTEMS ]; 1107ab: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx <== NOT EXECUTED 1107b1: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 1107b4: 80 78 76 01 cmpb $0x1,0x76(%eax) <== NOT EXECUTED 1107b8: 19 f6 sbb %esi,%esi <== NOT EXECUTED 1107ba: 81 e6 00 01 00 00 and $0x100,%esi <== NOT EXECUTED if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 1107c0: 8b 50 7c mov 0x7c(%eax),%edx <== NOT EXECUTED 1107c3: 85 d2 test %edx,%edx <== NOT EXECUTED 1107c5: 0f 85 bd 00 00 00 jne 110888 <== NOT EXECUTED old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 1107cb: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 1107ce: 80 7b 08 01 cmpb $0x1,0x8(%ebx) <== NOT EXECUTED 1107d2: 19 db sbb %ebx,%ebx <== NOT EXECUTED 1107d4: 81 e3 00 04 00 00 and $0x400,%ebx <== NOT EXECUTED old_mode |= _ISR_Get_level(); 1107da: e8 1d cf ff ff call 10d6fc <_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; 1107df: 09 c3 or %eax,%ebx <== NOT EXECUTED old_mode |= _ISR_Get_level(); *previous_mode_set = old_mode; 1107e1: 09 f3 or %esi,%ebx <== NOT EXECUTED 1107e3: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1107e6: 89 18 mov %ebx,(%eax) <== NOT EXECUTED /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 1107e8: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) <== NOT EXECUTED 1107ef: 74 11 je 110802 <== NOT EXECUTED executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE; 1107f1: 89 f8 mov %edi,%eax <== NOT EXECUTED 1107f3: c1 e8 08 shr $0x8,%eax <== NOT EXECUTED 1107f6: 83 f0 01 xor $0x1,%eax <== NOT EXECUTED 1107f9: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 1107fc: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 1107ff: 88 42 76 mov %al,0x76(%edx) <== NOT EXECUTED if ( mask & RTEMS_TIMESLICE_MASK ) { 110802: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) <== NOT EXECUTED 110809: 74 1e je 110829 <== NOT EXECUTED if ( _Modes_Is_timeslice(mode_set) ) { 11080b: f7 c7 00 02 00 00 test $0x200,%edi <== NOT EXECUTED 110811: 0f 84 81 00 00 00 je 110898 <== NOT EXECUTED executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 110817: 8b 5d ec mov -0x14(%ebp),%ebx <== NOT EXECUTED 11081a: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx) <== NOT EXECUTED executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 110821: a1 84 f7 11 00 mov 0x11f784,%eax <== NOT EXECUTED 110826: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 110829: f6 45 0c 01 testb $0x1,0xc(%ebp) <== NOT EXECUTED 11082d: 74 09 je 110838 <== 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 11082f: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED 110835: 74 5d je 110894 <== NOT EXECUTED 110837: fa cli <== NOT EXECUTED */ is_asr_enabled = FALSE; needs_asr_dispatching = FALSE; if ( mask & RTEMS_ASR_MASK ) { 110838: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) <== NOT EXECUTED 11083f: 74 31 je 110872 <== NOT EXECUTED 110841: c1 ef 0a shr $0xa,%edi <== NOT EXECUTED 110844: 83 f7 01 xor $0x1,%edi <== NOT EXECUTED 110847: 89 f8 mov %edi,%eax <== NOT EXECUTED 110849: 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 ) { 11084c: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 11084f: 38 42 08 cmp %al,0x8(%edx) <== NOT EXECUTED 110852: 74 1e je 110872 <== NOT EXECUTED asr->is_enabled = is_asr_enabled; 110854: 88 42 08 mov %al,0x8(%edx) <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 110857: 9c pushf <== NOT EXECUTED 110858: fa cli <== NOT EXECUTED 110859: 59 pop %ecx <== NOT EXECUTED /** 11085a: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 11085d: 8b 53 18 mov 0x18(%ebx),%edx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 110860: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 110863: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED * begin at @a starting_address. 110866: 89 53 14 mov %edx,0x14(%ebx) <== NOT EXECUTED * 110869: 51 push %ecx <== NOT EXECUTED 11086a: 9d popf <== NOT EXECUTED _ASR_Swap_signals( asr ); if ( _ASR_Are_signals_pending( asr ) ) { 11086b: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 11086e: 85 c0 test %eax,%eax <== NOT EXECUTED 110870: 75 56 jne 1108c8 <== NOT EXECUTED needs_asr_dispatching = true; executing->do_post_task_switch_extension = true; 110872: 31 db xor %ebx,%ebx <== NOT EXECUTED } } } if ( _System_state_Is_up(_System_state_Current) ) 110874: 83 3d 84 f9 11 00 03 cmpl $0x3,0x11f984 <== NOT EXECUTED 11087b: 74 2f je 1108ac <== NOT EXECUTED if ( _Thread_Evaluate_mode() || needs_asr_dispatching ) _Thread_Dispatch(); 11087d: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 11087f: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 110882: 5b pop %ebx <== NOT EXECUTED 110883: 5e pop %esi <== NOT EXECUTED 110884: 5f pop %edi <== NOT EXECUTED 110885: c9 leave <== NOT EXECUTED 110886: c3 ret <== NOT EXECUTED 110887: 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; 110888: 81 ce 00 02 00 00 or $0x200,%esi <== NOT EXECUTED 11088e: e9 38 ff ff ff jmp 1107cb <== NOT EXECUTED 110893: 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 110894: fb sti <== NOT EXECUTED 110895: eb a1 jmp 110838 <== NOT EXECUTED 110897: 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; 110898: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11089b: c7 40 7c 00 00 00 00 movl $0x0,0x7c(%eax) <== NOT EXECUTED /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 1108a2: f6 45 0c 01 testb $0x1,0xc(%ebp) <== NOT EXECUTED 1108a6: 74 90 je 110838 <== NOT EXECUTED 1108a8: eb 85 jmp 11082f <== NOT EXECUTED 1108aa: 66 90 xchg %ax,%ax <== NOT EXECUTED } } } if ( _System_state_Is_up(_System_state_Current) ) if ( _Thread_Evaluate_mode() || needs_asr_dispatching ) 1108ac: e8 73 01 00 00 call 110a24 <_Thread_Evaluate_mode> <== NOT EXECUTED 1108b1: 84 c0 test %al,%al <== NOT EXECUTED 1108b3: 75 04 jne 1108b9 <== NOT EXECUTED 1108b5: 84 db test %bl,%bl <== NOT EXECUTED 1108b7: 74 c4 je 11087d <== NOT EXECUTED _Thread_Dispatch(); 1108b9: e8 32 b9 ff ff call 10c1f0 <_Thread_Dispatch> <== NOT EXECUTED 1108be: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 1108c0: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1108c3: 5b pop %ebx <== NOT EXECUTED 1108c4: 5e pop %esi <== NOT EXECUTED 1108c5: 5f pop %edi <== NOT EXECUTED 1108c6: c9 leave <== NOT EXECUTED 1108c7: 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; 1108c8: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1108cb: c6 40 75 01 movb $0x1,0x75(%eax) <== NOT EXECUTED 1108cf: b3 01 mov $0x1,%bl <== NOT EXECUTED 1108d1: eb a1 jmp 110874 <== NOT EXECUTED 1108d3: 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 ) 1108d4: 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; } 1108d9: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1108dc: 5b pop %ebx <== NOT EXECUTED 1108dd: 5e pop %esi <== NOT EXECUTED 1108de: 5f pop %edi <== NOT EXECUTED 1108df: c9 leave <== NOT EXECUTED 1108e0: c3 ret <== NOT EXECUTED 0010b0f8 : rtems_status_code rtems_task_restart( Objects_Id id, uint32_t argument ) { 10b0f8: 55 push %ebp <== NOT EXECUTED 10b0f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b0fb: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10b0fe: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b101: 50 push %eax <== NOT EXECUTED 10b102: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b105: e8 8e 1c 00 00 call 10cd98 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10b10a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b10d: 8b 4d fc mov -0x4(%ebp),%ecx <== NOT EXECUTED 10b110: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b112: 75 20 jne 10b134 <== NOT EXECUTED case OBJECTS_LOCAL: if ( _Thread_Restart( the_thread, NULL, argument ) ) { 10b114: 52 push %edx <== NOT EXECUTED 10b115: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b118: 6a 00 push $0x0 <== NOT EXECUTED 10b11a: 50 push %eax <== NOT EXECUTED 10b11b: e8 9c 24 00 00 call 10d5bc <_Thread_Restart> <== NOT EXECUTED 10b120: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b123: 84 c0 test %al,%al <== NOT EXECUTED 10b125: 75 15 jne 10b13c <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10b127: e8 48 1c 00 00 call 10cd74 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b12c: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b131: c9 leave <== NOT EXECUTED 10b132: c3 ret <== NOT EXECUTED 10b133: 90 nop <== NOT EXECUTED { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 10b134: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b139: c9 leave <== NOT EXECUTED 10b13a: c3 ret <== NOT EXECUTED 10b13b: 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(); 10b13c: e8 33 1c 00 00 call 10cd74 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b141: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b143: c9 leave <== NOT EXECUTED 10b144: 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 26 1f 00 00 call 10d868 <_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 b9 1e 00 00 call 10d818 <_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 19 27 00 00 call 10e08c <_Thread_Resume> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b973: e8 a0 1e 00 00 call 10d818 <_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 00126664 : #include #include rtems_id rtems_task_self(void) { 126664: 55 push %ebp <== NOT EXECUTED 126665: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126667: a1 bc 1f 16 00 mov 0x161fbc,%eax <== NOT EXECUTED 12666c: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED return _Thread_Executing->Object.id; } 12666f: c9 leave <== NOT EXECUTED 126670: 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 4b 12 00 mov 0x124bb4,%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 4b 12 00 mov 0x124bdc,%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 13 1e 00 00 call 10ddc4 <_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 d0 1d 00 00 call 10dda0 <_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 4b 12 00 mov 0x124bdc,%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 84 12 00 movzbl 0x1284f4,%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 44 1d 00 00 call 1111a8 <_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 de 17 00 00 call 110c7c <_Thread_Change_priority> <== NOT EXECUTED 10f49e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _Thread_Enable_dispatch(); 10f4a1: e8 b2 1c 00 00 call 111158 <_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 6f 1b 00 00 call 10c370 <_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 1f 26 00 00 call 10ce48 <_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 17 1b 00 00 call 10c34c <_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 07 1b 00 00 call 10c34c <_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 62 1e 00 00 call 10d868 <_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 f5 1d 00 00 call 10d818 <_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 1b 2a 00 00 call 10e450 <_Thread_Suspend> <== NOT EXECUTED _Thread_Enable_dispatch(); 10ba35: e8 de 1d 00 00 call 10d818 <_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 00126878 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 126878: 55 push %ebp <== NOT EXECUTED 126879: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12687b: 56 push %esi <== NOT EXECUTED 12687c: 53 push %ebx <== NOT EXECUTED 12687d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 126880: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 126883: 85 db test %ebx,%ebx <== NOT EXECUTED 126885: 0f 84 a1 00 00 00 je 12692c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 12688b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12688e: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 126891: 50 push %eax <== NOT EXECUTED 126892: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 126895: e8 02 af fe ff call 11179c <_Thread_Get> <== NOT EXECUTED 12689a: 89 c6 mov %eax,%esi <== NOT EXECUTED switch (location) { 12689c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12689f: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 1268a2: 85 c0 test %eax,%eax <== NOT EXECUTED 1268a4: 75 2e jne 1268d4 <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 1268a6: 8b 86 04 01 00 00 mov 0x104(%esi),%eax <== NOT EXECUTED while (tvp) { 1268ac: 85 c0 test %eax,%eax <== NOT EXECUTED 1268ae: 75 0a jne 1268ba <== NOT EXECUTED 1268b0: eb 2e jmp 1268e0 <== NOT EXECUTED 1268b2: 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; 1268b4: 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) { 1268b6: 85 c0 test %eax,%eax <== NOT EXECUTED 1268b8: 74 26 je 1268e0 <== NOT EXECUTED if (tvp->ptr == ptr) { 1268ba: 39 58 04 cmp %ebx,0x4(%eax) <== NOT EXECUTED 1268bd: 75 f5 jne 1268b4 <== NOT EXECUTED tvp->dtor = dtor; 1268bf: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 1268c2: 89 50 10 mov %edx,0x10(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 1268c5: e8 ae ae fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 1268ca: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1268cc: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1268cf: 5b pop %ebx <== NOT EXECUTED 1268d0: 5e pop %esi <== NOT EXECUTED 1268d1: c9 leave <== NOT EXECUTED 1268d2: c3 ret <== NOT EXECUTED 1268d3: 90 nop <== NOT EXECUTED if ( !ptr ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 1268d4: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1268d9: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1268dc: 5b pop %ebx <== NOT EXECUTED 1268dd: 5e pop %esi <== NOT EXECUTED 1268de: c9 leave <== NOT EXECUTED 1268df: c3 ret <== NOT EXECUTED } /* * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) 1268e0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1268e3: 6a 14 push $0x14 <== NOT EXECUTED 1268e5: e8 c2 bf fe ff call 1128ac <_Workspace_Allocate> <== NOT EXECUTED 1268ea: 89 c2 mov %eax,%edx <== NOT EXECUTED _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 1268ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1268ef: 85 c0 test %eax,%eax <== NOT EXECUTED 1268f1: 74 2d je 126920 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 1268f3: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 1268f5: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED new->ptr = ptr; 1268f8: 89 5a 04 mov %ebx,0x4(%edx) <== NOT EXECUTED new->dtor = dtor; 1268fb: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1268fe: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 126901: 8b 86 04 01 00 00 mov 0x104(%esi),%eax <== NOT EXECUTED 126907: 89 02 mov %eax,(%edx) <== NOT EXECUTED the_thread->task_variables = new; 126909: 89 96 04 01 00 00 mov %edx,0x104(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 12690f: e8 64 ae fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 126914: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126916: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126919: 5b pop %ebx <== NOT EXECUTED 12691a: 5e pop %esi <== NOT EXECUTED 12691b: c9 leave <== NOT EXECUTED 12691c: c3 ret <== NOT EXECUTED 12691d: 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(); 126920: e8 53 ae fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 126925: b8 1a 00 00 00 mov $0x1a,%eax <== NOT EXECUTED 12692a: eb ad jmp 1268d9 <== NOT EXECUTED { Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 12692c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126931: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126934: 5b pop %ebx <== NOT EXECUTED 126935: 5e pop %esi <== NOT EXECUTED 126936: c9 leave <== NOT EXECUTED 126937: c3 ret <== NOT EXECUTED 00126938 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 126938: 55 push %ebp <== NOT EXECUTED 126939: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12693b: 56 push %esi <== NOT EXECUTED 12693c: 53 push %ebx <== NOT EXECUTED 12693d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 126940: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 126943: 85 db test %ebx,%ebx <== NOT EXECUTED 126945: 74 3f je 126986 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); 126947: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12694a: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 12694d: 50 push %eax <== NOT EXECUTED 12694e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 126951: e8 46 ae fe ff call 11179c <_Thread_Get> <== NOT EXECUTED 126956: 89 c6 mov %eax,%esi <== NOT EXECUTED switch (location) { 126958: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12695b: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 12695e: 85 c0 test %eax,%eax <== NOT EXECUTED 126960: 75 32 jne 126994 <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; 126962: 8b 96 04 01 00 00 mov 0x104(%esi),%edx <== NOT EXECUTED while (tvp) { 126968: 85 d2 test %edx,%edx <== NOT EXECUTED 12696a: 74 15 je 126981 <== NOT EXECUTED if (tvp->ptr == ptr) { 12696c: 39 5a 04 cmp %ebx,0x4(%edx) <== NOT EXECUTED 12696f: 75 08 jne 126979 <== NOT EXECUTED 126971: eb 4c jmp 1269bf <== NOT EXECUTED 126973: 90 nop <== NOT EXECUTED 126974: 39 5a 04 cmp %ebx,0x4(%edx) <== NOT EXECUTED 126977: 74 27 je 1269a0 <== 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; 126979: 89 d1 mov %edx,%ecx <== NOT EXECUTED } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 12697b: 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) { 12697d: 85 d2 test %edx,%edx <== NOT EXECUTED 12697f: 75 f3 jne 126974 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 126981: e8 f2 ad fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 126986: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12698b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12698e: 5b pop %ebx <== NOT EXECUTED 12698f: 5e pop %esi <== NOT EXECUTED 126990: c9 leave <== NOT EXECUTED 126991: c3 ret <== NOT EXECUTED 126992: 66 90 xchg %ax,%ax <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); switch (location) { 126994: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126999: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12699c: 5b pop %ebx <== NOT EXECUTED 12699d: 5e pop %esi <== NOT EXECUTED 12699e: c9 leave <== NOT EXECUTED 12699f: c3 ret <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; 1269a0: 8b 02 mov (%edx),%eax <== NOT EXECUTED 1269a2: 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 ); 1269a4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1269a7: 52 push %edx <== NOT EXECUTED 1269a8: 56 push %esi <== NOT EXECUTED 1269a9: e8 a6 00 00 00 call 126a54 <_RTEMS_Tasks_Invoke_task_variable_dtor> <== NOT EXECUTED _Thread_Enable_dispatch(); 1269ae: e8 c5 ad fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 1269b3: 31 c0 xor %eax,%eax <== NOT EXECUTED 1269b5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1269b8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1269bb: 5b pop %ebx <== NOT EXECUTED 1269bc: 5e pop %esi <== NOT EXECUTED 1269bd: c9 leave <== NOT EXECUTED 1269be: 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; 1269bf: 8b 02 mov (%edx),%eax <== NOT EXECUTED 1269c1: 89 86 04 01 00 00 mov %eax,0x104(%esi) <== NOT EXECUTED 1269c7: eb db jmp 1269a4 <== NOT EXECUTED 001269cc : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 1269cc: 55 push %ebp <== NOT EXECUTED 1269cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1269cf: 56 push %esi <== NOT EXECUTED 1269d0: 53 push %ebx <== NOT EXECUTED 1269d1: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 1269d4: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 1269d7: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 1269da: 85 db test %ebx,%ebx <== NOT EXECUTED 1269dc: 74 56 je 126a34 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !result ) 1269de: 85 f6 test %esi,%esi <== NOT EXECUTED 1269e0: 74 52 je 126a34 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 1269e2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1269e5: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1269e8: 50 push %eax <== NOT EXECUTED 1269e9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1269ec: e8 ab ad fe ff call 11179c <_Thread_Get> <== NOT EXECUTED switch (location) { 1269f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1269f4: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 1269f7: 85 d2 test %edx,%edx <== NOT EXECUTED 1269f9: 75 2d jne 126a28 <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 1269fb: 8b 80 04 01 00 00 mov 0x104(%eax),%eax <== NOT EXECUTED while (tvp) { 126a01: 85 c0 test %eax,%eax <== NOT EXECUTED 126a03: 75 09 jne 126a0e <== NOT EXECUTED 126a05: eb 39 jmp 126a40 <== NOT EXECUTED 126a07: 90 nop <== NOT EXECUTED */ *result = tvp->tval; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 126a08: 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) { 126a0a: 85 c0 test %eax,%eax <== NOT EXECUTED 126a0c: 74 32 je 126a40 <== NOT EXECUTED if (tvp->ptr == ptr) { 126a0e: 39 58 04 cmp %ebx,0x4(%eax) <== NOT EXECUTED 126a11: 75 f5 jne 126a08 <== NOT EXECUTED /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 126a13: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 126a16: 89 06 mov %eax,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 126a18: e8 5b ad fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 126a1d: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126a1f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126a22: 5b pop %ebx <== NOT EXECUTED 126a23: 5e pop %esi <== NOT EXECUTED 126a24: c9 leave <== NOT EXECUTED 126a25: c3 ret <== NOT EXECUTED 126a26: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !result ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 126a28: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126a2d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126a30: 5b pop %ebx <== NOT EXECUTED 126a31: 5e pop %esi <== NOT EXECUTED 126a32: c9 leave <== NOT EXECUTED 126a33: c3 ret <== NOT EXECUTED return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; 126a34: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126a39: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126a3c: 5b pop %ebx <== NOT EXECUTED 126a3d: 5e pop %esi <== NOT EXECUTED 126a3e: c9 leave <== NOT EXECUTED 126a3f: c3 ret <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 126a40: e8 33 ad fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 126a45: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126a4a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126a4d: 5b pop %ebx <== NOT EXECUTED 126a4e: 5e pop %esi <== NOT EXECUTED 126a4f: c9 leave <== NOT EXECUTED 126a50: 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 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10a867: 40 inc %eax <== NOT EXECUTED 10a868: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== 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 7c f8 11 00 pushl 0x11f87c <== NOT EXECUTED 10a87c: e8 7f 23 00 00 call 10cc00 <_Thread_Set_state> <== NOT EXECUTED _Watchdog_Initialize( 10a881: a1 7c f8 11 00 mov 0x11f87c,%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 b4 c1 10 00 movl $0x10c1b4,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 9c f8 11 00 push $0x11f89c <== NOT EXECUTED 10a8af: e8 a8 29 00 00 call 10d25c <_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 90 1a 00 00 call 10c34c <_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 4b 26 00 00 call 10cf14 <_Thread_Yield_processor> <== NOT EXECUTED _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); } _Thread_Enable_dispatch(); 10a8c9: e8 7e 1a 00 00 call 10c34c <_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 ec 2f 12 00 00 cmpb $0x0,0x122fec <== 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 6c 30 12 00 cmp 0x12306c,%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 d8 2f 12 00 mov 0x122fd8,%eax <== NOT EXECUTED 10b53b: 40 inc %eax <== NOT EXECUTED 10b53c: a3 d8 2f 12 00 mov %eax,0x122fd8 <== 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 9c 30 12 00 pushl 0x12309c <== NOT EXECUTED 10b54c: e8 23 24 00 00 call 10d974 <_Thread_Set_state> <== NOT EXECUTED _Watchdog_Initialize( 10b551: a1 9c 30 12 00 mov 0x12309c,%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 28 cf 10 00 movl $0x10cf28,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 6c 30 12 00 sub 0x12306c,%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 b0 30 12 00 push $0x1230b0 <== NOT EXECUTED 10b585: e8 c2 2a 00 00 call 10e04c <_Watchdog_Insert> <== NOT EXECUTED ); _Watchdog_Insert_seconds( &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); 10b58a: e8 31 1b 00 00 call 10d0c0 <_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 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 114416: e8 25 28 00 00 call 116c40 <_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 3e 44 00 00 call 11887c <_Watchdog_Remove> <== NOT EXECUTED 11443e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Enable_dispatch(); 114441: e8 3e 30 00 00 call 117484 <_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 0010b378 : rtems_status_code rtems_timer_create( rtems_name name, Objects_Id *id ) { 10b378: 55 push %ebp <== NOT EXECUTED 10b379: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b37b: 57 push %edi <== NOT EXECUTED 10b37c: 56 push %esi <== NOT EXECUTED 10b37d: 53 push %ebx <== NOT EXECUTED 10b37e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b381: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10b384: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 10b387: 85 f6 test %esi,%esi <== NOT EXECUTED 10b389: 74 71 je 10b3fc <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 10b38b: 85 ff test %edi,%edi <== NOT EXECUTED 10b38d: 0f 84 8d 00 00 00 je 10b420 <== NOT EXECUTED 10b393: a1 18 2e 12 00 mov 0x122e18,%eax <== NOT EXECUTED 10b398: 40 inc %eax <== NOT EXECUTED 10b399: a3 18 2e 12 00 mov %eax,0x122e18 <== NOT EXECUTED /* determine if the CPU has a TSC */ #define x86_has_tsc() \ (x86_capability & (1 << 4)) static inline unsigned long long 10b39e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b3a1: 68 a0 34 12 00 push $0x1234a0 <== NOT EXECUTED 10b3a6: e8 51 0f 00 00 call 10c2fc <_Objects_Allocate> <== NOT EXECUTED 10b3ab: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { 10b3ad: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b3b0: 85 c0 test %eax,%eax <== NOT EXECUTED 10b3b2: 74 58 je 10b40c <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_timer->the_class = TIMER_DORMANT; 10b3b4: c7 40 38 04 00 00 00 movl $0x4,0x38(%eax) <== NOT EXECUTED rdtsc(void) { /* Return the value of the on-chip cycle counter. */ unsigned long long result; asm volatile(".byte 0x0F, 0x31" : "=A" (result)); return result; 10b3bb: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED } /* rdtsc */ 10b3c2: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) <== NOT EXECUTED 10b3c9: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) <== NOT EXECUTED 10b3d0: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) <== NOT EXECUTED 10b3d7: 8b 48 08 mov 0x8(%eax),%ecx <== NOT EXECUTED 10b3da: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10b3dd: a1 bc 34 12 00 mov 0x1234bc,%eax <== NOT EXECUTED 10b3e2: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10b3e5: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Timer_Information, &the_timer->Object, (Objects_Name) name ); *id = the_timer->Object.id; 10b3e8: 89 0f mov %ecx,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10b3ea: e8 45 1c 00 00 call 10d034 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b3ef: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10b3f1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b3f4: 5b pop %ebx <== NOT EXECUTED 10b3f5: 5e pop %esi <== NOT EXECUTED 10b3f6: 5f pop %edi <== NOT EXECUTED 10b3f7: c9 leave <== NOT EXECUTED 10b3f8: c3 ret <== NOT EXECUTED 10b3f9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED Objects_Id *id ) { Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 10b3fc: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b401: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b404: 5b pop %ebx <== NOT EXECUTED 10b405: 5e pop %esi <== NOT EXECUTED 10b406: 5f pop %edi <== NOT EXECUTED 10b407: c9 leave <== NOT EXECUTED 10b408: c3 ret <== NOT EXECUTED 10b409: 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(); 10b40c: e8 23 1c 00 00 call 10d034 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b411: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b416: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b419: 5b pop %ebx <== NOT EXECUTED 10b41a: 5e pop %esi <== NOT EXECUTED 10b41b: 5f pop %edi <== NOT EXECUTED 10b41c: c9 leave <== NOT EXECUTED 10b41d: c3 ret <== NOT EXECUTED 10b41e: 66 90 xchg %ax,%ax <== NOT EXECUTED Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 10b420: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b425: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b428: 5b pop %ebx <== NOT EXECUTED 10b429: 5e pop %esi <== NOT EXECUTED 10b42a: 5f pop %edi <== NOT EXECUTED 10b42b: c9 leave <== NOT EXECUTED 10b42c: 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 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 114517: e8 24 27 00 00 call 116c40 <_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 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 114531: e8 56 22 00 00 call 11678c <_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 3b 43 00 00 call 11887c <_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 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 114549: e8 7e 25 00 00 call 116acc <_Objects_Free> <== NOT EXECUTED _Timer_Free( the_timer ); _Thread_Enable_dispatch(); 11454e: e8 31 2f 00 00 call 117484 <_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 0010b430 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 10b430: 55 push %ebp <== NOT EXECUTED 10b431: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b433: 57 push %edi <== NOT EXECUTED 10b434: 56 push %esi <== NOT EXECUTED 10b435: 53 push %ebx <== NOT EXECUTED 10b436: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10b439: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 10b43c: 85 f6 test %esi,%esi <== NOT EXECUTED 10b43e: 0f 84 98 00 00 00 je 10b4dc <== NOT EXECUTED return RTEMS_INVALID_NUMBER; if ( !routine ) 10b444: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10b447: 85 ff test %edi,%edi <== NOT EXECUTED 10b449: 0f 84 9d 00 00 00 je 10b4ec <== NOT EXECUTED 10b44f: 53 push %ebx <== NOT EXECUTED 10b450: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b453: 50 push %eax <== NOT EXECUTED 10b454: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b457: 68 a0 34 12 00 push $0x1234a0 <== NOT EXECUTED 10b45c: e8 8f 13 00 00 call 10c7f0 <_Objects_Get> <== NOT EXECUTED 10b461: 89 c3 mov %eax,%ebx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 10b463: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b466: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10b469: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b46b: 75 5f jne 10b4cc <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 10b46d: 8d 78 10 lea 0x10(%eax),%edi <== NOT EXECUTED 10b470: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b473: 57 push %edi <== NOT EXECUTED 10b474: e8 77 2c 00 00 call 10e0f0 <_Watchdog_Remove> <== NOT EXECUTED _ISR_Disable( level ); 10b479: 9c pushf <== NOT EXECUTED 10b47a: fa cli <== NOT EXECUTED 10b47b: 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 ) { 10b47c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b47f: 8b 53 18 mov 0x18(%ebx),%edx <== NOT EXECUTED 10b482: 85 d2 test %edx,%edx <== NOT EXECUTED 10b484: 75 76 jne 10b4fc <== 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; 10b486: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) <== NOT EXECUTED rdtsc(void) { /* Return the value of the on-chip cycle counter. */ unsigned long long result; asm volatile(".byte 0x0F, 0x31" : "=A" (result)); return result; 10b48d: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED } /* rdtsc */ 10b494: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10b497: 89 53 2c mov %edx,0x2c(%ebx) <== NOT EXECUTED 10b49a: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b49d: 89 53 30 mov %edx,0x30(%ebx) <== NOT EXECUTED 10b4a0: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10b4a3: 89 53 34 mov %edx,0x34(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 10b4a6: 50 push %eax <== NOT EXECUTED 10b4a7: 9d popf <== NOT EXECUTED 10b4a8: 89 73 1c mov %esi,0x1c(%ebx) <== NOT EXECUTED 10b4ab: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b4ae: 57 push %edi <== NOT EXECUTED 10b4af: 68 fc 2e 12 00 push $0x122efc <== NOT EXECUTED 10b4b4: e8 07 2b 00 00 call 10dfc0 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 10b4b9: e8 76 1b 00 00 call 10d034 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b4be: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b4c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b4c3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b4c6: 5b pop %ebx <== NOT EXECUTED 10b4c7: 5e pop %esi <== NOT EXECUTED 10b4c8: 5f pop %edi <== NOT EXECUTED 10b4c9: c9 leave <== NOT EXECUTED 10b4ca: c3 ret <== NOT EXECUTED 10b4cb: 90 nop <== NOT EXECUTED if ( !routine ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 10b4cc: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b4d1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b4d4: 5b pop %ebx <== NOT EXECUTED 10b4d5: 5e pop %esi <== NOT EXECUTED 10b4d6: 5f pop %edi <== NOT EXECUTED 10b4d7: c9 leave <== NOT EXECUTED 10b4d8: c3 ret <== NOT EXECUTED 10b4d9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 10b4dc: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b4e1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b4e4: 5b pop %ebx <== NOT EXECUTED 10b4e5: 5e pop %esi <== NOT EXECUTED 10b4e6: 5f pop %edi <== NOT EXECUTED 10b4e7: c9 leave <== NOT EXECUTED 10b4e8: c3 ret <== NOT EXECUTED 10b4e9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ISR_Level level; if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; if ( !routine ) 10b4ec: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b4f1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b4f4: 5b pop %ebx <== NOT EXECUTED 10b4f5: 5e pop %esi <== NOT EXECUTED 10b4f6: 5f pop %edi <== NOT EXECUTED 10b4f7: c9 leave <== NOT EXECUTED 10b4f8: c3 ret <== NOT EXECUTED 10b4f9: 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 ); 10b4fc: 50 push %eax <== NOT EXECUTED 10b4fd: 9d popf <== NOT EXECUTED _Thread_Enable_dispatch(); 10b4fe: e8 31 1b 00 00 call 10d034 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b503: 31 c0 xor %eax,%eax 10b505: eb ca jmp 10b4d1 <== 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 8c 6d 13 00 00 cmpb $0x0,0x136d8c <== 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 0c 6e 13 00 cmp 0x136e0c,%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 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 1146b5: e8 86 25 00 00 call 116c40 <_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 aa 41 00 00 call 11887c <_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 0c 6e 13 00 sub 0x136e0c,%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 50 6e 13 00 push $0x136e50 <== NOT EXECUTED 114703: e8 44 40 00 00 call 11874c <_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 77 2d 00 00 call 117484 <_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 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 11474b: e8 f0 24 00 00 call 116c40 <_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 00 2d 00 00 call 117484 <_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 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 1147ae: e8 e5 25 00 00 call 116d98 <_Objects_Name_to_id_u32> <== NOT EXECUTED 1147b3: 8b 04 85 74 b7 12 00 mov 0x12b774(,%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 b4 e3 12 00 movzbl 0x12e3b4,%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 78 6d 13 00 mov 0x136d78,%eax <== NOT EXECUTED 114a6e: 40 inc %eax <== NOT EXECUTED 114a6f: a3 78 6d 13 00 mov %eax,0x136d78 <== NOT EXECUTED /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 114a74: 8a 1d 40 27 13 00 mov 0x132740,%bl <== NOT EXECUTED initialized = true; 114a7a: c6 05 40 27 13 00 01 movb $0x1,0x132740 <== NOT EXECUTED _Thread_Enable_dispatch(); 114a81: e8 fe 29 00 00 call 117484 <_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 e0 6c 13 00 e4 movl $0x136ce4,0x136ce0 <== NOT EXECUTED 114aa7: 6c 13 00 <== NOT EXECUTED 114aaa: c7 05 e4 6c 13 00 00 movl $0x0,0x136ce4 <== NOT EXECUTED 114ab1: 00 00 00 <== NOT EXECUTED 114ab4: c7 05 e8 6c 13 00 e0 movl $0x136ce0,0x136ce8 <== NOT EXECUTED 114abb: 6c 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 90 6c 13 00 cmp 0x136c90,%cx <== NOT EXECUTED 114af7: 0f 86 b3 00 00 00 jbe 114bb0 <== NOT EXECUTED 114afd: 31 c0 xor %eax,%eax <== NOT EXECUTED 114aff: a3 e4 77 13 00 mov %eax,0x1377e4 <== NOT EXECUTED 114b04: c7 05 c0 6c 13 00 c4 movl $0x136cc4,0x136cc0 <== NOT EXECUTED 114b0b: 6c 13 00 <== NOT EXECUTED 114b0e: c7 05 c4 6c 13 00 00 movl $0x0,0x136cc4 <== NOT EXECUTED 114b15: 00 00 00 <== NOT EXECUTED 114b18: c7 05 c8 6c 13 00 c0 movl $0x136cc0,0x136cc8 <== NOT EXECUTED 114b1f: 6c 13 00 <== NOT EXECUTED 114b22: c7 05 d4 6c 13 00 d8 movl $0x136cd8,0x136cd4 <== NOT EXECUTED 114b29: 6c 13 00 <== NOT EXECUTED 114b2c: c7 05 d8 6c 13 00 00 movl $0x0,0x136cd8 <== NOT EXECUTED 114b33: 00 00 00 <== NOT EXECUTED 114b36: c7 05 dc 6c 13 00 d4 movl $0x136cd4,0x136cdc <== NOT EXECUTED 114b3d: 6c 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 ec 72 11 00 movl $0x1172ec,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 08 6d 13 00 00 movl $0x0,0x136d08 <== NOT EXECUTED 114b5f: 00 00 00 <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 114b62: c7 05 1c 6d 13 00 ec movl $0x1172ec,0x136d1c <== NOT EXECUTED 114b69: 72 11 00 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 114b6c: 89 0d 20 6d 13 00 mov %ecx,0x136d20 <== NOT EXECUTED * the heap 114b72: c7 05 24 6d 13 00 00 movl $0x0,0x136d24 <== 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 e0 77 13 00 c0 movl $0x114bc0,0x1377e0 <== 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 40 27 13 00 00 movb $0x0,0x132740 <== 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 9c 6c 13 00 mov 0x136c9c,%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 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 1147cf: e8 6c 24 00 00 call 116c40 <_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 7a 40 00 00 call 11887c <_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 5c 6e 13 00 push $0x136e5c <== NOT EXECUTED 11480a: e8 3d 3f 00 00 call 11874c <_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 6d 2c 00 00 call 117484 <_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 5a 2c 00 00 call 117484 <_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 e0 77 13 00 mov 0x1377e0,%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 33 40 00 00 call 11887c <_Watchdog_Remove> <== NOT EXECUTED (*_Timer_Server_schedule_operation)( the_timer ); 114849: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 11484c: ff 15 e0 77 13 00 call *0x1377e0 <== 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 27 2c 00 00 call 117484 <_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 e4 77 13 00 mov 0x1377e4,%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 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 1148a1: e8 9a 23 00 00 call 116c40 <_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 be 3f 00 00 call 11887c <_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 e0 77 13 00 call *0x1377e0 <== NOT EXECUTED _Thread_Enable_dispatch(); 1148fd: e8 82 2b 00 00 call 117484 <_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 65 2b 00 00 call 117484 <_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 e4 77 13 00 mov 0x1377e4,%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 8c 6d 13 00 00 cmpb $0x0,0x136d8c <== 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 0c 6e 13 00 cmp 0x136e0c,%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 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 1149b1: e8 8a 22 00 00 call 116c40 <_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 ae 3e 00 00 call 11887c <_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 0c 6e 13 00 sub 0x136e0c,%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 e0 77 13 00 call *0x1377e0 <== NOT EXECUTED _Thread_Enable_dispatch(); 114a00: e8 7f 2a 00 00 call 117484 <_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 0010b09c : */ bool rtems_workspace_allocate( uintptr_t bytes, void **pointer ) { 10b09c: 55 push %ebp <== NOT EXECUTED 10b09d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b09f: 53 push %ebx <== NOT EXECUTED 10b0a0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b0a3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b0a6: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED void *ptr; /* * check the arguments */ if ( !pointer ) 10b0a9: 85 db test %ebx,%ebx <== NOT EXECUTED 10b0ab: 74 04 je 10b0b1 <== NOT EXECUTED return false; if ( !bytes ) 10b0ad: 85 c0 test %eax,%eax <== NOT EXECUTED 10b0af: 75 07 jne 10b0b8 <== NOT EXECUTED ptr = _Protected_heap_Allocate( &_Workspace_Area, (intptr_t) bytes ); if (!ptr) return false; *pointer = ptr; return true; 10b0b1: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10b0b3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b0b6: c9 leave <== NOT EXECUTED 10b0b7: c3 ret <== NOT EXECUTED return false; /* * Allocate the memory */ ptr = _Protected_heap_Allocate( &_Workspace_Area, (intptr_t) bytes ); 10b0b8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b0bb: 50 push %eax <== NOT EXECUTED 10b0bc: 68 c0 3c 12 00 push $0x123cc0 <== NOT EXECUTED 10b0c1: e8 b2 15 00 00 call 10c678 <_Protected_heap_Allocate> <== NOT EXECUTED if (!ptr) 10b0c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b0c9: 85 c0 test %eax,%eax <== NOT EXECUTED 10b0cb: 74 e4 je 10b0b1 <== NOT EXECUTED return false; *pointer = ptr; 10b0cd: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10b0cf: b0 01 mov $0x1,%al <== NOT EXECUTED return true; } 10b0d1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b0d4: c9 leave <== NOT EXECUTED 10b0d5: c3 ret <== NOT EXECUTED 0010b084 : * _Workspace_Allocate */ bool rtems_workspace_free( void *pointer ) { 10b084: 55 push %ebp <== NOT EXECUTED 10b085: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b087: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _Protected_heap_Free( &_Workspace_Area, pointer ); 10b08a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b08d: 68 c0 3c 12 00 push $0x123cc0 <== NOT EXECUTED 10b092: e8 15 16 00 00 call 10c6ac <_Protected_heap_Free> <== NOT EXECUTED } 10b097: c9 leave <== NOT EXECUTED 10b098: c3 ret <== NOT EXECUTED 0010b0d8 : #include /* for memset */ bool rtems_workspace_get_information( Heap_Information_block *the_info ) { 10b0d8: 55 push %ebp <== NOT EXECUTED 10b0d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b0db: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b0de: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !the_info ) 10b0e1: 85 c0 test %eax,%eax <== NOT EXECUTED 10b0e3: 74 11 je 10b0f6 <== NOT EXECUTED return false; return _Protected_heap_Get_information( &_Workspace_Area, the_info ); 10b0e5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b0e8: 50 push %eax <== NOT EXECUTED 10b0e9: 68 c0 3c 12 00 push $0x123cc0 <== NOT EXECUTED 10b0ee: e8 ed 15 00 00 call 10c6e0 <_Protected_heap_Get_information> <== NOT EXECUTED 10b0f3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b0f6: c9 leave <== NOT EXECUTED 10b0f7: c3 ret <== NOT EXECUTED 0010b480 : #include int sched_get_priority_max( int policy ) { 10b480: 55 push %ebp <== NOT EXECUTED 10b481: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b483: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED switch ( policy ) { 10b486: 83 7d 08 03 cmpl $0x3,0x8(%ebp) <== NOT EXECUTED 10b48a: 76 14 jbe 10b4a0 <== NOT EXECUTED case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10b48c: e8 4f 71 00 00 call 1125e0 <__errno> <== NOT EXECUTED 10b491: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b497: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; } 10b49c: c9 leave <== NOT EXECUTED 10b49d: c3 ret <== NOT EXECUTED 10b49e: 66 90 xchg %ax,%ax <== NOT EXECUTED int sched_get_priority_max( int policy ) { switch ( policy ) { 10b4a0: b8 fe 00 00 00 mov $0xfe,%eax <== NOT EXECUTED default: rtems_set_errno_and_return_minus_one( EINVAL ); } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; } 10b4a5: c9 leave <== NOT EXECUTED 10b4a6: c3 ret <== NOT EXECUTED 0010b4a8 : #include int sched_get_priority_min( int policy ) { 10b4a8: 55 push %ebp <== NOT EXECUTED 10b4a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4ab: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED switch ( policy ) { 10b4ae: 83 7d 08 03 cmpl $0x3,0x8(%ebp) <== NOT EXECUTED 10b4b2: 76 14 jbe 10b4c8 <== NOT EXECUTED case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10b4b4: e8 27 71 00 00 call 1125e0 <__errno> <== NOT EXECUTED 10b4b9: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b4bf: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } return POSIX_SCHEDULER_MINIMUM_PRIORITY; } 10b4c4: c9 leave <== NOT EXECUTED 10b4c5: c3 ret <== NOT EXECUTED 10b4c6: 66 90 xchg %ax,%ax <== NOT EXECUTED int sched_get_priority_min( int policy ) { switch ( policy ) { 10b4c8: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED default: rtems_set_errno_and_return_minus_one( EINVAL ); } return POSIX_SCHEDULER_MINIMUM_PRIORITY; } 10b4cd: c9 leave <== NOT EXECUTED 10b4ce: c3 ret <== NOT EXECUTED 0010a44c : int sched_getparam( pid_t pid, const struct sched_param *param ) { 10a44c: 55 push %ebp <== NOT EXECUTED 10a44d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a44f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a452: e8 29 76 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a457: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a45d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a462: c9 leave <== NOT EXECUTED 10a463: c3 ret <== NOT EXECUTED 0010a464 : #include int sched_getscheduler( pid_t pid ) { 10a464: 55 push %ebp <== NOT EXECUTED 10a465: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a467: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a46a: e8 11 76 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a46f: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a475: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a47a: c9 leave <== NOT EXECUTED 10a47b: c3 ret <== NOT EXECUTED 0010b4d0 : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 10b4d0: 55 push %ebp <== NOT EXECUTED 10b4d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4d3: 56 push %esi <== NOT EXECUTED 10b4d4: 53 push %ebx <== NOT EXECUTED 10b4d5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b4d8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 10b4db: 85 db test %ebx,%ebx <== NOT EXECUTED 10b4dd: 75 21 jne 10b500 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ESRCH ); if ( !interval ) 10b4df: 85 f6 test %esi,%esi <== NOT EXECUTED 10b4e1: 74 38 je 10b51b <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 10b4e3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b4e6: 56 push %esi <== NOT EXECUTED 10b4e7: ff 35 84 33 12 00 pushl 0x123384 <== NOT EXECUTED 10b4ed: e8 7a 37 00 00 call 10ec6c <_Timespec_From_ticks> <== NOT EXECUTED 10b4f2: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b4f4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10b4f7: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b4fa: 5b pop %ebx <== NOT EXECUTED 10b4fb: 5e pop %esi <== NOT EXECUTED 10b4fc: c9 leave <== NOT EXECUTED 10b4fd: c3 ret <== NOT EXECUTED 10b4fe: 66 90 xchg %ax,%ax <== NOT EXECUTED { /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 10b500: e8 07 cb ff ff call 10800c <== NOT EXECUTED 10b505: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10b507: 74 d6 je 10b4df <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ESRCH ); 10b509: e8 d2 70 00 00 call 1125e0 <__errno> <== NOT EXECUTED 10b50e: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED 10b514: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10b519: eb dc jmp 10b4f7 <== NOT EXECUTED if ( !interval ) rtems_set_errno_and_return_minus_one( EINVAL ); 10b51b: e8 c0 70 00 00 call 1125e0 <__errno> <== NOT EXECUTED 10b520: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b526: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10b52b: eb ca jmp 10b4f7 <== NOT EXECUTED 0010a47c : int sched_setparam( pid_t pid, const struct sched_param *param ) { 10a47c: 55 push %ebp <== NOT EXECUTED 10a47d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a47f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a482: e8 f9 75 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a487: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a48d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a492: c9 leave <== NOT EXECUTED 10a493: c3 ret <== NOT EXECUTED 0010a494 : int sched_setscheduler( pid_t pid, int policy, const struct sched_param *param ) { 10a494: 55 push %ebp <== NOT EXECUTED 10a495: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a497: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a49a: e8 e1 75 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a49f: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a4a5: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a4aa: c9 leave <== NOT EXECUTED 10a4ab: c3 ret <== NOT EXECUTED 0010b530 : #include #include #include int sched_yield( void ) { 10b530: 55 push %ebp <== NOT EXECUTED 10b531: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b533: 83 ec 08 sub $0x8,%esp <== 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 33 12 00 mov 0x1233b8,%eax <== NOT EXECUTED 10b53b: 40 inc %eax <== NOT EXECUTED 10b53c: a3 b8 33 12 00 mov %eax,0x1233b8 <== NOT EXECUTED _Thread_Disable_dispatch(); _Thread_Yield_processor(); 10b541: e8 86 36 00 00 call 10ebcc <_Thread_Yield_processor> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b546: e8 8d 2a 00 00 call 10dfd8 <_Thread_Enable_dispatch> <== NOT EXECUTED return 0; } 10b54b: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b54d: c9 leave <== NOT EXECUTED 10b54e: c3 ret <== NOT EXECUTED 0010c800 : */ int sem_close( sem_t *sem ) { 10c800: 55 push %ebp <== NOT EXECUTED 10c801: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c803: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED * 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( Heap_Control *the_heap, 10c806: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10c809: 50 push %eax <== NOT EXECUTED 10c80a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c80d: ff 30 pushl (%eax) <== NOT EXECUTED 10c80f: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 10c814: e8 07 23 00 00 call 10eb20 <_Objects_Get> <== NOT EXECUTED register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 10c819: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c81c: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10c81f: 85 d2 test %edx,%edx <== NOT EXECUTED 10c821: 74 15 je 10c838 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10c823: e8 60 7c 00 00 call 114488 <__errno> <== NOT EXECUTED 10c828: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c82e: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 10c833: c9 leave <== NOT EXECUTED 10c834: c3 ret <== NOT EXECUTED 10c835: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_LOCAL: the_semaphore->open_count -= 1; 10c838: ff 48 18 decl 0x18(%eax) <== NOT EXECUTED _POSIX_Semaphore_Delete( the_semaphore ); 10c83b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c83e: 50 push %eax <== NOT EXECUTED 10c83f: e8 78 5f 00 00 call 1127bc <_POSIX_Semaphore_Delete> <== NOT EXECUTED _Thread_Enable_dispatch(); 10c844: e8 1b 2b 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c849: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c84b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10c84e: c9 leave <== NOT EXECUTED 10c84f: c3 ret <== NOT EXECUTED 0010c850 : */ int sem_destroy( sem_t *sem ) { 10c850: 55 push %ebp <== NOT EXECUTED 10c851: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c853: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10c856: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10c859: 50 push %eax <== NOT EXECUTED 10c85a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c85d: ff 30 pushl (%eax) <== NOT EXECUTED 10c85f: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 10c864: e8 b7 22 00 00 call 10eb20 <_Objects_Get> <== NOT EXECUTED register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 10c869: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c86c: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10c86f: 85 d2 test %edx,%edx <== NOT EXECUTED 10c871: 74 15 je 10c888 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10c873: e8 10 7c 00 00 call 114488 <__errno> <== NOT EXECUTED 10c878: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c87e: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 10c883: c9 leave <== NOT EXECUTED 10c884: c3 ret <== NOT EXECUTED 10c885: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED case OBJECTS_LOCAL: /* * Undefined operation on a named semaphore. */ if ( the_semaphore->named == TRUE ) { 10c888: 80 78 14 00 cmpb $0x0,0x14(%eax) <== NOT EXECUTED 10c88c: 75 16 jne 10c8a4 <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } _POSIX_Semaphore_Delete( the_semaphore ); 10c88e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c891: 50 push %eax <== NOT EXECUTED 10c892: e8 25 5f 00 00 call 1127bc <_POSIX_Semaphore_Delete> <== NOT EXECUTED _Thread_Enable_dispatch(); 10c897: e8 c8 2a 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c89c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c89e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10c8a1: c9 leave <== NOT EXECUTED 10c8a2: c3 ret <== NOT EXECUTED 10c8a3: 90 nop <== NOT EXECUTED /* * Undefined operation on a named semaphore. */ if ( the_semaphore->named == TRUE ) { _Thread_Enable_dispatch(); 10c8a4: e8 bb 2a 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 10c8a9: e8 da 7b 00 00 call 114488 <__errno> <== NOT EXECUTED 10c8ae: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c8b4: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10c8b9: c9 leave <== NOT EXECUTED 10c8ba: c3 ret <== NOT EXECUTED 0010c8bc : int sem_getvalue( sem_t *sem, int *sval ) { 10c8bc: 55 push %ebp <== NOT EXECUTED 10c8bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c8bf: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10c8c2: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10c8c5: 50 push %eax <== NOT EXECUTED 10c8c6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c8c9: ff 30 pushl (%eax) <== NOT EXECUTED 10c8cb: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 10c8d0: e8 4b 22 00 00 call 10eb20 <_Objects_Get> <== NOT EXECUTED register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 10c8d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c8d8: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10c8db: 85 d2 test %edx,%edx <== NOT EXECUTED 10c8dd: 74 15 je 10c8f4 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10c8df: e8 a4 7b 00 00 call 114488 <__errno> <== NOT EXECUTED 10c8e4: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c8ea: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 10c8ef: c9 leave <== NOT EXECUTED 10c8f0: c3 ret <== NOT EXECUTED 10c8f1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_LOCAL: *sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore ); 10c8f4: 8b 40 64 mov 0x64(%eax),%eax <== NOT EXECUTED 10c8f7: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10c8fa: 89 02 mov %eax,(%edx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10c8fc: e8 63 2a 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c901: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10c903: c9 leave <== NOT EXECUTED 10c904: c3 ret <== NOT EXECUTED 0010c908 : int sem_init( sem_t *sem, int pshared, unsigned int value ) { 10c908: 55 push %ebp <== NOT EXECUTED 10c909: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c90b: 53 push %ebx <== NOT EXECUTED 10c90c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10c90f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED int status; POSIX_Semaphore_Control *the_semaphore; if ( !sem ) 10c912: 85 db test %ebx,%ebx <== NOT EXECUTED 10c914: 74 2a je 10c940 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); status = _POSIX_Semaphore_Create_support( 10c916: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10c919: 50 push %eax <== NOT EXECUTED 10c91a: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10c91d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c920: 6a 00 push $0x0 <== NOT EXECUTED 10c922: e8 7d 5d 00 00 call 1126a4 <_POSIX_Semaphore_Create_support> <== NOT EXECUTED 10c927: 89 c2 mov %eax,%edx <== NOT EXECUTED pshared, value, &the_semaphore ); if ( status != -1 ) 10c929: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c92c: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10c92f: 74 08 je 10c939 <== NOT EXECUTED *sem = the_semaphore->Object.id; 10c931: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10c934: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10c937: 89 03 mov %eax,(%ebx) <== NOT EXECUTED return status; } 10c939: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c93b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c93e: c9 leave <== NOT EXECUTED 10c93f: c3 ret <== NOT EXECUTED { int status; POSIX_Semaphore_Control *the_semaphore; if ( !sem ) rtems_set_errno_and_return_minus_one( EINVAL ); 10c940: e8 43 7b 00 00 call 114488 <__errno> <== NOT EXECUTED 10c945: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c94b: ba ff ff ff ff mov $0xffffffff,%edx <== NOT EXECUTED 10c950: eb e7 jmp 10c939 <== NOT EXECUTED 0010c954 : int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) { 10c954: 55 push %ebp <== NOT EXECUTED 10c955: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c957: 57 push %edi <== NOT EXECUTED 10c958: 56 push %esi <== NOT EXECUTED 10c959: 53 push %ebx <== NOT EXECUTED 10c95a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10c95d: 8b 75 0c mov 0xc(%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 10c960: a1 d8 58 12 00 mov 0x1258d8,%eax <== NOT EXECUTED 10c965: 40 inc %eax <== NOT EXECUTED 10c966: a3 d8 58 12 00 mov %eax,0x1258d8 <== NOT EXECUTED POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10c96b: 89 f7 mov %esi,%edi <== NOT EXECUTED 10c96d: 81 e7 00 02 00 00 and $0x200,%edi <== NOT EXECUTED 10c973: 0f 85 8b 00 00 00 jne 10ca04 <== NOT EXECUTED 10c979: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); va_end(arg); } status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 10c980: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c983: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10c986: 50 push %eax <== NOT EXECUTED 10c987: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c98a: e8 7d 5e 00 00 call 11280c <_POSIX_Semaphore_Name_to_id> <== NOT EXECUTED 10c98f: 89 c3 mov %eax,%ebx <== NOT EXECUTED * and we can just return a pointer to the id. Otherwise we may * need to check to see if this is a "semaphore does not exist" * or some other miscellaneous error on the name. */ if ( status ) { 10c991: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c994: 85 c0 test %eax,%eax <== NOT EXECUTED 10c996: 74 28 je 10c9c0 <== NOT EXECUTED /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 10c998: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10c99b: 75 08 jne 10c9a5 <== NOT EXECUTED 10c99d: 85 ff test %edi,%edi <== NOT EXECUTED 10c99f: 0f 85 8b 00 00 00 jne 10ca30 <== NOT EXECUTED _Thread_Enable_dispatch(); 10c9a5: e8 ba 29 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 10c9aa: e8 d9 7a 00 00 call 114488 <__errno> <== NOT EXECUTED 10c9af: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10c9b1: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED if ( status == -1 ) return SEM_FAILED; id = &the_semaphore->Object.id; return (sem_t *)id; } 10c9b6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c9b9: 5b pop %ebx <== NOT EXECUTED 10c9ba: 5e pop %esi <== NOT EXECUTED 10c9bb: 5f pop %edi <== NOT EXECUTED 10c9bc: c9 leave <== NOT EXECUTED 10c9bd: c3 ret <== NOT EXECUTED 10c9be: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10c9c0: 81 e6 00 0a 00 00 and $0xa00,%esi <== NOT EXECUTED 10c9c6: 81 fe 00 0a 00 00 cmp $0xa00,%esi <== NOT EXECUTED 10c9cc: 74 42 je 10ca10 <== NOT EXECUTED * 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( Heap_Control *the_heap, 10c9ce: 50 push %eax <== NOT EXECUTED 10c9cf: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10c9d2: 50 push %eax <== NOT EXECUTED 10c9d3: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10c9d6: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 10c9db: e8 40 21 00 00 call 10eb20 <_Objects_Get> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); } the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); 10c9e0: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED the_semaphore->open_count += 1; 10c9e3: ff 40 18 incl 0x18(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10c9e6: e8 79 29 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED _Thread_Enable_dispatch(); 10c9eb: e8 74 29 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED id = &the_semaphore->Object.id; return (sem_t *)id; 10c9f0: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10c9f3: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 10c9f6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( status == -1 ) return SEM_FAILED; id = &the_semaphore->Object.id; return (sem_t *)id; } 10c9f9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c9fc: 5b pop %ebx <== NOT EXECUTED 10c9fd: 5e pop %esi <== NOT EXECUTED 10c9fe: 5f pop %edi <== NOT EXECUTED 10c9ff: c9 leave <== NOT EXECUTED 10ca00: c3 ret <== NOT EXECUTED 10ca01: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); 10ca04: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10ca07: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10ca0a: e9 71 ff ff ff jmp 10c980 <== NOT EXECUTED 10ca0f: 90 nop <== NOT EXECUTED /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { _Thread_Enable_dispatch(); 10ca10: e8 4f 29 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 10ca15: e8 6e 7a 00 00 call 114488 <__errno> <== NOT EXECUTED 10ca1a: c7 00 11 00 00 00 movl $0x11,(%eax) <== NOT EXECUTED 10ca20: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED if ( status == -1 ) return SEM_FAILED; id = &the_semaphore->Object.id; return (sem_t *)id; } 10ca25: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ca28: 5b pop %ebx <== NOT EXECUTED 10ca29: 5e pop %esi <== NOT EXECUTED 10ca2a: 5f pop %edi <== NOT EXECUTED 10ca2b: c9 leave <== NOT EXECUTED 10ca2c: c3 ret <== NOT EXECUTED 10ca2d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * At this point, the semaphore does not exist and everything has been * checked. We should go ahead and create a semaphore. */ status =_POSIX_Semaphore_Create_support( 10ca30: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10ca33: 50 push %eax <== NOT EXECUTED 10ca34: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10ca37: 6a 00 push $0x0 <== NOT EXECUTED 10ca39: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ca3c: e8 63 5c 00 00 call 1126a4 <_POSIX_Semaphore_Create_support> <== NOT EXECUTED 10ca41: 89 c3 mov %eax,%ebx <== NOT EXECUTED /* * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); 10ca43: e8 1c 29 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( status == -1 ) 10ca48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ca4b: 43 inc %ebx <== NOT EXECUTED 10ca4c: 74 0a je 10ca58 <== NOT EXECUTED return SEM_FAILED; id = &the_semaphore->Object.id; return (sem_t *)id; 10ca4e: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10ca51: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 10ca54: eb a3 jmp 10c9f9 <== NOT EXECUTED 10ca56: 66 90 xchg %ax,%ax <== NOT EXECUTED * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); if ( status == -1 ) 10ca58: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ca5d: eb 9a jmp 10c9f9 <== NOT EXECUTED 0010ca60 : */ int sem_post( sem_t *sem ) { 10ca60: 55 push %ebp <== NOT EXECUTED 10ca61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca63: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10ca66: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10ca69: 50 push %eax <== NOT EXECUTED 10ca6a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ca6d: ff 30 pushl (%eax) <== NOT EXECUTED 10ca6f: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 10ca74: e8 a7 20 00 00 call 10eb20 <_Objects_Get> <== NOT EXECUTED register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 10ca79: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ca7c: 8b 4d fc mov -0x4(%ebp),%ecx <== NOT EXECUTED 10ca7f: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ca81: 74 15 je 10ca98 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10ca83: e8 00 7a 00 00 call 114488 <__errno> <== NOT EXECUTED 10ca88: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10ca8e: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 10ca93: c9 leave <== NOT EXECUTED 10ca94: c3 ret <== NOT EXECUTED 10ca95: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_semaphore_Surrender( 10ca98: 52 push %edx <== NOT EXECUTED 10ca99: 6a 00 push $0x0 <== NOT EXECUTED 10ca9b: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10ca9e: 83 c0 1c add $0x1c,%eax <== NOT EXECUTED 10caa1: 50 push %eax <== NOT EXECUTED 10caa2: e8 cd 17 00 00 call 10e274 <_CORE_semaphore_Surrender> <== NOT EXECUTED NULL /* XXX need to define a routine to handle this case */ #else NULL #endif ); _Thread_Enable_dispatch(); 10caa7: e8 b8 28 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED 10caac: 31 c0 xor %eax,%eax <== NOT EXECUTED 10caae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10cab1: c9 leave <== NOT EXECUTED 10cab2: c3 ret <== NOT EXECUTED 0010cab4 : int sem_timedwait( sem_t *sem, const struct timespec *abstime ) { 10cab4: 55 push %ebp <== NOT EXECUTED 10cab5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cab7: 53 push %ebx <== NOT EXECUTED 10cab8: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10cabb: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10cabe: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10cac1: 50 push %eax <== NOT EXECUTED 10cac2: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10cac5: e8 b2 52 00 00 call 111d7c <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED switch ( status ) { 10caca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cacd: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10cad0: 76 16 jbe 10cae8 <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = true; break; } lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 10cad2: 52 push %edx <== NOT EXECUTED 10cad3: ff 75 f8 pushl -0x8(%ebp) <== NOT EXECUTED 10cad6: 6a 01 push $0x1 <== NOT EXECUTED 10cad8: 53 push %ebx <== NOT EXECUTED 10cad9: e8 92 5d 00 00 call 112870 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED 10cade: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } } return lock_status; } 10cae1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cae4: c9 leave <== NOT EXECUTED 10cae5: c3 ret <== NOT EXECUTED 10cae6: 66 90 xchg %ax,%ax <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = true; break; } lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 10cae8: 50 push %eax <== NOT EXECUTED 10cae9: ff 75 f8 pushl -0x8(%ebp) <== NOT EXECUTED 10caec: 6a 00 push $0x0 <== NOT EXECUTED 10caee: 53 push %ebx <== NOT EXECUTED 10caef: e8 7c 5d 00 00 call 112870 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED 10caf4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } } return lock_status; } 10caf7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cafa: c9 leave <== NOT EXECUTED 10cafb: c3 ret <== NOT EXECUTED 0010cafc : */ int sem_trywait( sem_t *sem ) { 10cafc: 55 push %ebp <== NOT EXECUTED 10cafd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10caff: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return _POSIX_Semaphore_Wait_support(sem, FALSE, THREAD_QUEUE_WAIT_FOREVER); 10cb02: 6a 00 push $0x0 <== NOT EXECUTED 10cb04: 6a 00 push $0x0 <== NOT EXECUTED 10cb06: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cb09: e8 62 5d 00 00 call 112870 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED } 10cb0e: c9 leave <== NOT EXECUTED 10cb0f: c3 ret <== NOT EXECUTED 0010cb10 : */ int sem_unlink( const char *name ) { 10cb10: 55 push %ebp <== NOT EXECUTED 10cb11: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cb13: 53 push %ebx <== NOT EXECUTED 10cb14: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10cb17: a1 d8 58 12 00 mov 0x1258d8,%eax <== NOT EXECUTED 10cb1c: 40 inc %eax <== NOT EXECUTED 10cb1d: a3 d8 58 12 00 mov %eax,0x1258d8 <== NOT EXECUTED register POSIX_Semaphore_Control *the_semaphore; sem_t the_semaphore_id; _Thread_Disable_dispatch(); status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 10cb22: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10cb25: 50 push %eax <== NOT EXECUTED 10cb26: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cb29: e8 de 5c 00 00 call 11280c <_POSIX_Semaphore_Name_to_id> <== NOT EXECUTED 10cb2e: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( status != 0 ) { 10cb30: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cb33: 85 c0 test %eax,%eax <== NOT EXECUTED 10cb35: 75 45 jne 10cb7c <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( status ); } the_semaphore = (POSIX_Semaphore_Control *) _Objects_Get_local_object( 10cb37: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 10cb3a: 66 3b 05 30 5c 12 00 cmp 0x125c30,%ax <== NOT EXECUTED 10cb41: 77 35 ja 10cb78 <== NOT EXECUTED 10cb43: 0f b7 d0 movzwl %ax,%edx <== NOT EXECUTED 10cb46: a1 3c 5c 12 00 mov 0x125c3c,%eax <== NOT EXECUTED 10cb4b: 8b 1c 90 mov (%eax,%edx,4),%ebx <== NOT EXECUTED &_POSIX_Semaphore_Information, _Objects_Get_index( the_semaphore_id ) ); the_semaphore->linked = FALSE; 10cb4e: c6 43 15 00 movb $0x0,0x15(%ebx) <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10cb52: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10cb55: 53 push %ebx <== NOT EXECUTED 10cb56: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 10cb5b: e8 e4 20 00 00 call 10ec44 <_Objects_Namespace_remove> <== NOT EXECUTED _POSIX_Semaphore_Namespace_remove( the_semaphore ); _POSIX_Semaphore_Delete( the_semaphore ); 10cb60: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10cb63: e8 54 5c 00 00 call 1127bc <_POSIX_Semaphore_Delete> <== NOT EXECUTED _Thread_Enable_dispatch(); 10cb68: e8 f7 27 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED 10cb6d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cb6f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10cb72: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cb75: c9 leave <== NOT EXECUTED 10cb76: c3 ret <== NOT EXECUTED 10cb77: 90 nop <== NOT EXECUTED bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 10cb78: 31 db xor %ebx,%ebx <== NOT EXECUTED 10cb7a: eb d2 jmp 10cb4e <== NOT EXECUTED _Thread_Disable_dispatch(); status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); if ( status != 0 ) { _Thread_Enable_dispatch(); 10cb7c: e8 e3 27 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( status ); 10cb81: e8 02 79 00 00 call 114488 <__errno> <== NOT EXECUTED 10cb86: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10cb88: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10cb8d: eb e3 jmp 10cb72 <== NOT EXECUTED 0010cb90 : */ int sem_wait( sem_t *sem ) { 10cb90: 55 push %ebp <== NOT EXECUTED 10cb91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cb93: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return _POSIX_Semaphore_Wait_support( sem, TRUE, THREAD_QUEUE_WAIT_FOREVER ); 10cb96: 6a 00 push $0x0 <== NOT EXECUTED 10cb98: 6a 01 push $0x1 <== NOT EXECUTED 10cb9a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cb9d: e8 ce 5c 00 00 call 112870 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED } 10cba2: c9 leave <== NOT EXECUTED 10cba3: c3 ret <== NOT EXECUTED 0010a990 : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 10a990: 55 push %ebp <== NOT EXECUTED 10a991: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a993: 57 push %edi <== NOT EXECUTED 10a994: 56 push %esi <== NOT EXECUTED 10a995: 53 push %ebx <== NOT EXECUTED 10a996: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a999: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a99c: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED ISR_Level level; if ( oact ) 10a99f: 85 ff test %edi,%edi <== NOT EXECUTED 10a9a1: 74 11 je 10a9b4 <== NOT EXECUTED *oact = _POSIX_signals_Vectors[ sig ]; 10a9a3: 8d 04 5b lea (%ebx,%ebx,2),%eax <== NOT EXECUTED 10a9a6: 8d 34 85 a0 29 12 00 lea 0x1229a0(,%eax,4),%esi <== NOT EXECUTED 10a9ad: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 10a9b2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !sig ) 10a9b4: 85 db test %ebx,%ebx <== NOT EXECUTED 10a9b6: 74 74 je 10aa2c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 10a9b8: 8d 4b ff lea -0x1(%ebx),%ecx <== NOT EXECUTED 10a9bb: 83 f9 1f cmp $0x1f,%ecx <== NOT EXECUTED 10a9be: 77 6c ja 10aa2c <== NOT EXECUTED * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 10a9c0: 83 fb 09 cmp $0x9,%ebx <== NOT EXECUTED 10a9c3: 74 67 je 10aa2c <== NOT EXECUTED /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 10a9c5: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10a9c8: 85 d2 test %edx,%edx <== NOT EXECUTED 10a9ca: 74 3a je 10aa06 <== NOT EXECUTED /* * Unless the user is installing the default signal actions, then * we can just copy the provided sigaction structure into the vectors. */ _ISR_Disable( level ); 10a9cc: 9c pushf <== NOT EXECUTED 10a9cd: fa cli <== NOT EXECUTED 10a9ce: 8f 45 f0 popl -0x10(%ebp) <== NOT EXECUTED if ( act->sa_handler == SIG_DFL ) { 10a9d1: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a9d4: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10a9d7: 85 c0 test %eax,%eax <== NOT EXECUTED 10a9d9: 74 35 je 10aa10 <== NOT EXECUTED _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; } else { _POSIX_signals_Clear_process_signals( signo_to_mask(sig) ); 10a9db: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a9de: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10a9e3: d3 e0 shl %cl,%eax <== NOT EXECUTED 10a9e5: 50 push %eax <== NOT EXECUTED 10a9e6: e8 85 56 00 00 call 110070 <_POSIX_signals_Clear_process_signals> <== NOT EXECUTED _POSIX_signals_Vectors[ sig ] = *act; 10a9eb: 8d 04 5b lea (%ebx,%ebx,2),%eax <== NOT EXECUTED 10a9ee: 8d 3c 85 a0 29 12 00 lea 0x1229a0(,%eax,4),%edi <== NOT EXECUTED 10a9f5: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 10a9fa: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10a9fd: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10a9ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _ISR_Enable( level ); 10aa02: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10aa05: 9d popf <== NOT EXECUTED 10aa06: 31 c0 xor %eax,%eax <== NOT EXECUTED * + If we are now ignoring a signal that was previously pending, * we clear the pending signal indicator. */ return 0; } 10aa08: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aa0b: 5b pop %ebx <== NOT EXECUTED 10aa0c: 5e pop %esi <== NOT EXECUTED 10aa0d: 5f pop %edi <== NOT EXECUTED 10aa0e: c9 leave <== NOT EXECUTED 10aa0f: c3 ret <== NOT EXECUTED * we can just copy the provided sigaction structure into the vectors. */ _ISR_Disable( level ); if ( act->sa_handler == SIG_DFL ) { _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 10aa10: 8d 04 5b lea (%ebx,%ebx,2),%eax <== NOT EXECUTED 10aa13: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10aa16: 8d b8 a0 29 12 00 lea 0x1229a0(%eax),%edi <== NOT EXECUTED 10aa1c: 8d b0 20 bf 11 00 lea 0x11bf20(%eax),%esi <== NOT EXECUTED 10aa22: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 10aa27: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10aa29: eb d7 jmp 10aa02 <== NOT EXECUTED 10aa2b: 90 nop <== NOT EXECUTED * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) rtems_set_errno_and_return_minus_one( EINVAL ); 10aa2c: e8 9b 72 00 00 call 111ccc <__errno> <== NOT EXECUTED 10aa31: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10aa37: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10aa3c: eb ca jmp 10aa08 <== NOT EXECUTED 0010aa40 : int sigaddset( sigset_t *set, int signo ) { 10aa40: 55 push %ebp <== NOT EXECUTED 10aa41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa43: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10aa46: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10aa49: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED if ( !set ) 10aa4c: 85 d2 test %edx,%edx <== NOT EXECUTED 10aa4e: 74 1c je 10aa6c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !signo ) 10aa50: 85 c0 test %eax,%eax <== NOT EXECUTED 10aa52: 74 18 je 10aa6c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(signo) ) 10aa54: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED 10aa57: 83 f9 1f cmp $0x1f,%ecx <== NOT EXECUTED 10aa5a: 77 10 ja 10aa6c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); *set |= signo_to_mask(signo); 10aa5c: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10aa61: d3 e0 shl %cl,%eax <== NOT EXECUTED 10aa63: 09 02 or %eax,(%edx) <== NOT EXECUTED 10aa65: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10aa67: c9 leave <== NOT EXECUTED 10aa68: c3 ret <== NOT EXECUTED 10aa69: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !signo ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(signo) ) rtems_set_errno_and_return_minus_one( EINVAL ); 10aa6c: e8 5b 72 00 00 call 111ccc <__errno> <== NOT EXECUTED 10aa71: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10aa77: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED *set |= signo_to_mask(signo); return 0; } 10aa7c: c9 leave <== NOT EXECUTED 10aa7d: c3 ret <== NOT EXECUTED 0010c748 : int sigdelset( sigset_t *set, int signo ) { 10c748: 55 push %ebp <== NOT EXECUTED 10c749: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c74b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c74e: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c751: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED if ( !set ) 10c754: 85 d2 test %edx,%edx <== NOT EXECUTED 10c756: 74 1c je 10c774 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !signo ) 10c758: 85 c0 test %eax,%eax <== NOT EXECUTED 10c75a: 74 13 je 10c76f <== NOT EXECUTED return 0; if ( !is_valid_signo(signo) ) 10c75c: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED 10c75f: 83 f9 1f cmp $0x1f,%ecx <== NOT EXECUTED 10c762: 77 10 ja 10c774 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); *set &= ~signo_to_mask(signo); 10c764: b8 fe ff ff ff mov $0xfffffffe,%eax <== NOT EXECUTED 10c769: d3 c0 rol %cl,%eax <== NOT EXECUTED 10c76b: 21 02 and %eax,(%edx) <== NOT EXECUTED 10c76d: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10c76f: c9 leave <== NOT EXECUTED 10c770: c3 ret <== NOT EXECUTED 10c771: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !signo ) return 0; if ( !is_valid_signo(signo) ) rtems_set_errno_and_return_minus_one( EINVAL ); 10c774: e8 43 78 00 00 call 113fbc <__errno> <== NOT EXECUTED 10c779: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c77f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED *set &= ~signo_to_mask(signo); return 0; } 10c784: c9 leave <== NOT EXECUTED 10c785: c3 ret <== NOT EXECUTED 0010f264 : #include int sigemptyset( sigset_t *set ) { 10f264: 55 push %ebp <== NOT EXECUTED 10f265: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f267: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f26a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !set ) 10f26d: 85 c0 test %eax,%eax <== NOT EXECUTED 10f26f: 74 0a je 10f27b <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); *set = 0; 10f271: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 10f277: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10f279: c9 leave <== NOT EXECUTED 10f27a: c3 ret <== NOT EXECUTED int sigemptyset( sigset_t *set ) { if ( !set ) rtems_set_errno_and_return_minus_one( EINVAL ); 10f27b: e8 00 1a 00 00 call 110c80 <__errno> <== NOT EXECUTED 10f280: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10f286: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED *set = 0; return 0; } 10f28b: c9 leave <== NOT EXECUTED 10f28c: c3 ret <== NOT EXECUTED 0010c7b4 : #include int sigfillset( sigset_t *set ) { 10c7b4: 55 push %ebp <== NOT EXECUTED 10c7b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c7b7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c7ba: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !set ) 10c7bd: 85 c0 test %eax,%eax <== NOT EXECUTED 10c7bf: 74 0a je 10c7cb <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); *set = SIGNAL_ALL_MASK; 10c7c1: c7 00 ff ff ff ff movl $0xffffffff,(%eax) <== NOT EXECUTED 10c7c7: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10c7c9: c9 leave <== NOT EXECUTED 10c7ca: c3 ret <== NOT EXECUTED int sigfillset( sigset_t *set ) { if ( !set ) rtems_set_errno_and_return_minus_one( EINVAL ); 10c7cb: e8 ec 77 00 00 call 113fbc <__errno> <== NOT EXECUTED 10c7d0: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c7d6: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED *set = SIGNAL_ALL_MASK; return 0; } 10c7db: c9 leave <== NOT EXECUTED 10c7dc: c3 ret <== NOT EXECUTED 0010c7e0 : int sigismember( const sigset_t *set, int signo ) { 10c7e0: 55 push %ebp <== NOT EXECUTED 10c7e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c7e3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c7e6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c7e9: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED if ( !set ) 10c7ec: 85 d2 test %edx,%edx <== NOT EXECUTED 10c7ee: 74 20 je 10c810 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !signo ) 10c7f0: 85 c0 test %eax,%eax <== NOT EXECUTED 10c7f2: 74 17 je 10c80b <== NOT EXECUTED return 0; if ( !is_valid_signo(signo) ) 10c7f4: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED 10c7f7: 83 f9 1f cmp $0x1f,%ecx <== NOT EXECUTED 10c7fa: 77 14 ja 10c810 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 10c7fc: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10c801: d3 e0 shl %cl,%eax <== NOT EXECUTED 10c803: 85 02 test %eax,(%edx) <== NOT EXECUTED 10c805: 0f 95 c0 setne %al <== NOT EXECUTED 10c808: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED if ( *set & signo_to_mask(signo) ) return 1; return 0; } 10c80b: c9 leave <== NOT EXECUTED 10c80c: c3 ret <== NOT EXECUTED 10c80d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !signo ) return 0; if ( !is_valid_signo(signo) ) rtems_set_errno_and_return_minus_one( EINVAL ); 10c810: e8 a7 77 00 00 call 113fbc <__errno> <== NOT EXECUTED 10c815: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c81b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED if ( *set & signo_to_mask(signo) ) return 1; return 0; } 10c820: c9 leave <== NOT EXECUTED 10c821: c3 ret <== NOT EXECUTED 0010a5c0 : sighandler_t signal( int signum, sighandler_t handler ) { 10a5c0: 55 push %ebp <== NOT EXECUTED 10a5c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a5c3: 53 push %ebx <== NOT EXECUTED 10a5c4: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED struct sigaction s; struct sigaction old; s.sa_handler = handler ; 10a5c7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a5ca: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED sigemptyset(&s.sa_mask); 10a5cd: 8d 5d f0 lea -0x10(%ebp),%ebx <== NOT EXECUTED 10a5d0: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10a5d3: 50 push %eax <== NOT EXECUTED 10a5d4: e8 bb ff ff ff call 10a594 <== NOT EXECUTED s.sa_flags = SA_RESTART | SA_INTERRUPT | SA_NOMASK; s.sa_restorer= NULL ; #elif defined(signal_like_SVR4) s.sa_flags = SA_RESTART; #else s.sa_flags = 0; 10a5d9: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED #endif sigaction( signum, &s, &old ); 10a5e0: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10a5e3: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10a5e6: 50 push %eax <== NOT EXECUTED 10a5e7: 53 push %ebx <== NOT EXECUTED 10a5e8: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a5eb: e8 b4 fe ff ff call 10a4a4 <== NOT EXECUTED 10a5f0: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED return (sighandler_t) old.sa_handler; } 10a5f3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a5f6: c9 leave <== NOT EXECUTED 10a5f7: c3 ret <== NOT EXECUTED 0010aaac : #include int sigpending( sigset_t *set ) { 10aaac: 55 push %ebp <== NOT EXECUTED 10aaad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aaaf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10aab2: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED POSIX_API_Control *api; if ( !set ) 10aab5: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10aab7: 74 1c je 10aad5 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; *set = api->signals_pending | _POSIX_signals_Pending; 10aab9: a1 1c 24 12 00 mov 0x12241c,%eax <== NOT EXECUTED 10aabe: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx <== NOT EXECUTED 10aac4: a1 80 2b 12 00 mov 0x122b80,%eax <== NOT EXECUTED 10aac9: 0b 82 c8 00 00 00 or 0xc8(%edx),%eax <== NOT EXECUTED 10aacf: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10aad1: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10aad3: c9 leave <== NOT EXECUTED 10aad4: c3 ret <== NOT EXECUTED ) { POSIX_API_Control *api; if ( !set ) rtems_set_errno_and_return_minus_one( EINVAL ); 10aad5: e8 f2 71 00 00 call 111ccc <__errno> <== NOT EXECUTED 10aada: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10aae0: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; *set = api->signals_pending | _POSIX_signals_Pending; return 0; } 10aae5: c9 leave <== NOT EXECUTED 10aae6: c3 ret <== NOT EXECUTED 0010aae8 : int sigprocmask( int how, const sigset_t *set, sigset_t *oset ) { 10aae8: 55 push %ebp <== NOT EXECUTED 10aae9: 89 e5 mov %esp,%ebp <== NOT EXECUTED /* * P1003.1c/Draft 10, p. 38 maps sigprocmask to pthread_sigmask. */ return pthread_sigmask( how, set, oset ); } 10aaeb: c9 leave <== NOT EXECUTED { /* * P1003.1c/Draft 10, p. 38 maps sigprocmask to pthread_sigmask. */ return pthread_sigmask( how, set, oset ); 10aaec: e9 53 59 00 00 jmp 110444 <== NOT EXECUTED 0010c86c : int sigqueue( pid_t pid, int signo, const union sigval value ) { 10c86c: 55 push %ebp <== NOT EXECUTED 10c86d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c86f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return killinfo( pid, signo, &value ); 10c872: 8d 45 10 lea 0x10(%ebp),%eax <== NOT EXECUTED 10c875: 50 push %eax <== NOT EXECUTED 10c876: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c879: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c87c: e8 bf 56 00 00 call 111f40 <== NOT EXECUTED } 10c881: c9 leave <== NOT EXECUTED 10c882: c3 ret <== NOT EXECUTED 0010c884 : #include int sigsuspend( const sigset_t *sigmask ) { 10c884: 55 push %ebp <== NOT EXECUTED 10c885: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c887: 56 push %esi <== NOT EXECUTED 10c888: 53 push %ebx <== NOT EXECUTED 10c889: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED int status; POSIX_API_Control *api; api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; status = sigprocmask( SIG_BLOCK, sigmask, &saved_signals_blocked ); 10c88c: 8d 5d f4 lea -0xc(%ebp),%ebx <== NOT EXECUTED 10c88f: 53 push %ebx <== NOT EXECUTED 10c890: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c893: 6a 01 push $0x1 <== NOT EXECUTED 10c895: e8 c6 ff ff ff call 10c860 <== NOT EXECUTED (void) sigfillset( &all_signals ); 10c89a: 8d 75 f0 lea -0x10(%ebp),%esi <== NOT EXECUTED 10c89d: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10c8a0: e8 0f ff ff ff call 10c7b4 <== NOT EXECUTED status = sigtimedwait( &all_signals, NULL, NULL ); 10c8a5: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c8a8: 6a 00 push $0x0 <== NOT EXECUTED 10c8aa: 6a 00 push $0x0 <== NOT EXECUTED 10c8ac: 56 push %esi <== NOT EXECUTED 10c8ad: e8 7e 00 00 00 call 10c930 <== NOT EXECUTED 10c8b2: 89 c6 mov %eax,%esi <== NOT EXECUTED (void) sigprocmask( SIG_SETMASK, &saved_signals_blocked, NULL ); 10c8b4: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c8b7: 6a 00 push $0x0 <== NOT EXECUTED 10c8b9: 53 push %ebx <== NOT EXECUTED 10c8ba: 6a 00 push $0x0 <== NOT EXECUTED 10c8bc: e8 9f ff ff ff call 10c860 <== NOT EXECUTED /* * sigtimedwait() returns the signal number while sigsuspend() * is supposed to return -1 and EINTR when a signal is caught. */ if ( status != -1 ) 10c8c1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c8c4: 46 inc %esi <== NOT EXECUTED 10c8c5: 75 0d jne 10c8d4 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINTR ); return status; } 10c8c7: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10c8cc: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c8cf: 5b pop %ebx <== NOT EXECUTED 10c8d0: 5e pop %esi <== NOT EXECUTED 10c8d1: c9 leave <== NOT EXECUTED 10c8d2: c3 ret <== NOT EXECUTED 10c8d3: 90 nop <== NOT EXECUTED /* * sigtimedwait() returns the signal number while sigsuspend() * is supposed to return -1 and EINTR when a signal is caught. */ if ( status != -1 ) rtems_set_errno_and_return_minus_one( EINTR ); 10c8d4: e8 e3 76 00 00 call 113fbc <__errno> <== NOT EXECUTED 10c8d9: c7 00 04 00 00 00 movl $0x4,(%eax) <== NOT EXECUTED 10c8df: eb e6 jmp 10c8c7 <== NOT EXECUTED 0010adc8 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 10adc8: 55 push %ebp <== NOT EXECUTED 10adc9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10adcb: 57 push %edi <== NOT EXECUTED 10adcc: 56 push %esi <== NOT EXECUTED 10adcd: 53 push %ebx <== NOT EXECUTED 10adce: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10add1: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10add4: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED * NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; if ( timeout ) { 10add7: 85 db test %ebx,%ebx <== NOT EXECUTED 10add9: 0f 84 1d 01 00 00 je 10aefc <== NOT EXECUTED if ( !_Timespec_Is_valid( timeout ) ) 10addf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ade2: 53 push %ebx <== NOT EXECUTED 10ade3: e8 60 36 00 00 call 10e448 <_Timespec_Is_valid> <== NOT EXECUTED 10ade8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10adeb: 84 c0 test %al,%al <== NOT EXECUTED 10aded: 0f 84 55 01 00 00 je 10af48 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 10adf3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10adf6: 53 push %ebx <== NOT EXECUTED 10adf7: e8 b0 36 00 00 call 10e4ac <_Timespec_To_ticks> <== NOT EXECUTED 10adfc: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !interval ) 10adfe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae01: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae03: 0f 84 3f 01 00 00 je 10af48 <== NOT EXECUTED /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 10ae09: 85 f6 test %esi,%esi <== NOT EXECUTED 10ae0b: 0f 84 f5 00 00 00 je 10af06 <== NOT EXECUTED the_thread = _Thread_Executing; 10ae11: 8b 0d 7c 2b 12 00 mov 0x122b7c,%ecx <== NOT EXECUTED api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10ae17: 8b b9 f8 00 00 00 mov 0xf8(%ecx),%edi <== NOT EXECUTED * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 10ae1d: 9c pushf <== NOT EXECUTED 10ae1e: fa cli <== NOT EXECUTED 10ae1f: 8f 45 e0 popl -0x20(%ebp) <== NOT EXECUTED if ( *set & api->signals_pending ) { 10ae22: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ae25: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10ae27: 8b 87 c8 00 00 00 mov 0xc8(%edi),%eax <== NOT EXECUTED 10ae2d: 85 c2 test %eax,%edx <== NOT EXECUTED 10ae2f: 0f 85 db 00 00 00 jne 10af10 <== NOT EXECUTED return the_info->si_signo; } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 10ae35: a1 e0 32 12 00 mov 0x1232e0,%eax <== NOT EXECUTED 10ae3a: 85 c2 test %eax,%edx <== NOT EXECUTED 10ae3c: 0f 85 82 00 00 00 jne 10aec4 <== NOT EXECUTED the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; return signo; } the_info->si_signo = -1; 10ae42: c7 06 ff ff ff ff movl $0xffffffff,(%esi) <== NOT EXECUTED 10ae48: a1 b8 2a 12 00 mov 0x122ab8,%eax <== NOT EXECUTED 10ae4d: 40 inc %eax <== NOT EXECUTED 10ae4e: a3 b8 2a 12 00 mov %eax,0x122ab8 <== NOT EXECUTED _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 10ae53: c7 41 44 a0 32 12 00 movl $0x1232a0,0x44(%ecx) <== NOT EXECUTED the_thread->Wait.return_code = EINTR; 10ae5a: c7 41 34 04 00 00 00 movl $0x4,0x34(%ecx) <== NOT EXECUTED the_thread->Wait.option = *set; 10ae61: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10ae64: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10ae66: 89 41 30 mov %eax,0x30(%ecx) <== NOT EXECUTED the_thread->Wait.return_argument = the_info; 10ae69: 89 71 28 mov %esi,0x28(%ecx) <== NOT EXECUTED 10ae6c: c7 05 d0 32 12 00 01 movl $0x1,0x1232d0 <== NOT EXECUTED 10ae73: 00 00 00 <== NOT EXECUTED _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue ); _ISR_Enable( level ); 10ae76: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10ae79: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 10ae7a: 50 push %eax <== NOT EXECUTED 10ae7b: 68 f0 df 10 00 push $0x10dff0 <== NOT EXECUTED 10ae80: 53 push %ebx <== NOT EXECUTED 10ae81: 68 a0 32 12 00 push $0x1232a0 <== NOT EXECUTED 10ae86: e8 15 2e 00 00 call 10dca0 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 10ae8b: e8 50 29 00 00 call 10d7e0 <_Thread_Enable_dispatch> <== NOT EXECUTED /* * When the thread is set free by a signal, it is need to eliminate * the signal. */ _POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false ); 10ae90: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED 10ae97: 6a 00 push $0x0 <== NOT EXECUTED 10ae99: 56 push %esi <== NOT EXECUTED 10ae9a: ff 36 pushl (%esi) <== NOT EXECUTED 10ae9c: 57 push %edi <== NOT EXECUTED 10ae9d: e8 d2 58 00 00 call 110774 <_POSIX_signals_Clear_signals> <== NOT EXECUTED errno = _Thread_Executing->Wait.return_code; 10aea2: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10aea5: e8 a6 74 00 00 call 112350 <__errno> <== NOT EXECUTED 10aeaa: 8b 15 7c 2b 12 00 mov 0x122b7c,%edx <== NOT EXECUTED 10aeb0: 8b 52 34 mov 0x34(%edx),%edx <== NOT EXECUTED 10aeb3: 89 10 mov %edx,(%eax) <== NOT EXECUTED return the_info->si_signo; 10aeb5: 8b 1e mov (%esi),%ebx <== NOT EXECUTED } 10aeb7: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10aeb9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aebc: 5b pop %ebx <== NOT EXECUTED 10aebd: 5e pop %esi <== NOT EXECUTED 10aebe: 5f pop %edi <== NOT EXECUTED 10aebf: c9 leave <== NOT EXECUTED 10aec0: c3 ret <== NOT EXECUTED 10aec1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending ); 10aec4: 50 push %eax <== NOT EXECUTED 10aec5: e8 b2 fe ff ff call 10ad7c <_POSIX_signals_Get_highest> <== NOT EXECUTED 10aeca: 89 c3 mov %eax,%ebx <== NOT EXECUTED _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); 10aecc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10aecf: 6a 00 push $0x0 <== NOT EXECUTED 10aed1: 6a 01 push $0x1 <== NOT EXECUTED 10aed3: 56 push %esi <== NOT EXECUTED 10aed4: 50 push %eax <== NOT EXECUTED 10aed5: 57 push %edi <== NOT EXECUTED 10aed6: e8 99 58 00 00 call 110774 <_POSIX_signals_Clear_signals> <== NOT EXECUTED _ISR_Enable( level ); 10aedb: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10aede: 9d popf <== NOT EXECUTED the_info->si_signo = signo; 10aedf: 89 1e mov %ebx,(%esi) <== NOT EXECUTED the_info->si_code = SI_USER; 10aee1: c7 46 04 01 00 00 00 movl $0x1,0x4(%esi) <== NOT EXECUTED the_info->si_value.sival_int = 0; 10aee8: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) <== NOT EXECUTED 10aeef: 83 c4 20 add $0x20,%esp <== NOT EXECUTED */ _POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false ); errno = _Thread_Executing->Wait.return_code; return the_info->si_signo; } 10aef2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10aef4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aef7: 5b pop %ebx <== NOT EXECUTED 10aef8: 5e pop %esi <== NOT EXECUTED 10aef9: 5f pop %edi <== NOT EXECUTED 10aefa: c9 leave <== NOT EXECUTED 10aefb: c3 ret <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); if ( !interval ) rtems_set_errno_and_return_minus_one( EINVAL ); 10aefc: 31 db xor %ebx,%ebx <== NOT EXECUTED /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 10aefe: 85 f6 test %esi,%esi <== NOT EXECUTED 10af00: 0f 85 0b ff ff ff jne 10ae11 <== NOT EXECUTED 10af06: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 10af09: e9 03 ff ff ff jmp 10ae11 <== NOT EXECUTED 10af0e: 66 90 xchg %ax,%ax <== NOT EXECUTED /* API signals pending? */ _ISR_Disable( level ); if ( *set & api->signals_pending ) { /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_highest( api->signals_pending ); 10af10: 50 push %eax <== NOT EXECUTED 10af11: e8 66 fe ff ff call 10ad7c <_POSIX_signals_Get_highest> <== NOT EXECUTED 10af16: 89 06 mov %eax,(%esi) <== NOT EXECUTED _POSIX_signals_Clear_signals( 10af18: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10af1b: 6a 00 push $0x0 <== NOT EXECUTED 10af1d: 6a 00 push $0x0 <== NOT EXECUTED 10af1f: 56 push %esi <== NOT EXECUTED 10af20: 50 push %eax <== NOT EXECUTED 10af21: 57 push %edi <== NOT EXECUTED 10af22: e8 4d 58 00 00 call 110774 <_POSIX_signals_Clear_signals> <== NOT EXECUTED the_info->si_signo, the_info, false, false ); _ISR_Enable( level ); 10af27: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10af2a: 9d popf <== NOT EXECUTED the_info->si_code = SI_USER; 10af2b: c7 46 04 01 00 00 00 movl $0x1,0x4(%esi) <== NOT EXECUTED the_info->si_value.sival_int = 0; 10af32: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) <== NOT EXECUTED return the_info->si_signo; 10af39: 8b 1e mov (%esi),%ebx <== NOT EXECUTED 10af3b: 83 c4 20 add $0x20,%esp <== NOT EXECUTED */ _POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false ); errno = _Thread_Executing->Wait.return_code; return the_info->si_signo; } 10af3e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10af40: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10af43: 5b pop %ebx <== NOT EXECUTED 10af44: 5e pop %esi <== NOT EXECUTED 10af45: 5f pop %edi <== NOT EXECUTED 10af46: c9 leave <== NOT EXECUTED 10af47: c3 ret <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); if ( !interval ) rtems_set_errno_and_return_minus_one( EINVAL ); 10af48: e8 03 74 00 00 call 112350 <__errno> <== NOT EXECUTED 10af4d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10af53: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10af58: e9 5a ff ff ff jmp 10aeb7 <== NOT EXECUTED 0010cae0 : int sigwait( const sigset_t *set, int *sig ) { 10cae0: 55 push %ebp <== NOT EXECUTED 10cae1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cae3: 53 push %ebx <== NOT EXECUTED 10cae4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10cae7: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED int status; status = sigtimedwait( set, NULL, NULL ); 10caea: 6a 00 push $0x0 <== NOT EXECUTED 10caec: 6a 00 push $0x0 <== NOT EXECUTED 10caee: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10caf1: e8 3a fe ff ff call 10c930 <== NOT EXECUTED if ( status != -1 ) { 10caf6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10caf9: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10cafc: 74 0e je 10cb0c <== NOT EXECUTED if ( sig ) 10cafe: 85 db test %ebx,%ebx <== NOT EXECUTED 10cb00: 74 02 je 10cb04 <== NOT EXECUTED *sig = status; 10cb02: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10cb04: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } return errno; } 10cb06: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cb09: c9 leave <== NOT EXECUTED 10cb0a: c3 ret <== NOT EXECUTED 10cb0b: 90 nop <== NOT EXECUTED if ( sig ) *sig = status; return 0; } return errno; 10cb0c: e8 ab 74 00 00 call 113fbc <__errno> <== NOT EXECUTED 10cb11: 8b 00 mov (%eax),%eax <== NOT EXECUTED } 10cb13: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cb16: c9 leave <== NOT EXECUTED 10cb17: c3 ret <== NOT EXECUTED 0010cac8 : int sigwaitinfo( const sigset_t *set, siginfo_t *info ) { 10cac8: 55 push %ebp <== NOT EXECUTED 10cac9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cacb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return sigtimedwait( set, info, NULL ); 10cace: 6a 00 push $0x0 <== NOT EXECUTED 10cad0: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10cad3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cad6: e8 55 fe ff ff call 10c930 <== NOT EXECUTED } 10cadb: c9 leave <== NOT EXECUTED 10cadc: c3 ret <== NOT EXECUTED 00109c9c : unsigned int sleep( unsigned int seconds ) { 109c9c: 55 push %ebp <== NOT EXECUTED 109c9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109c9f: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED struct timespec tp; struct timespec tm; tp.tv_sec = seconds; 109ca2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109ca5: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED tp.tv_nsec = 0; 109ca8: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED nanosleep( &tp, &tm ); 109caf: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 109cb2: 50 push %eax <== NOT EXECUTED 109cb3: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109cb6: 50 push %eax <== NOT EXECUTED 109cb7: e8 18 55 00 00 call 10f1d4 <== NOT EXECUTED 109cbc: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED return tm.tv_sec; /* seconds remaining */ } 109cbf: c9 leave <== NOT EXECUTED 109cc0: c3 ret <== NOT EXECUTED 00109ca0 : */ long sysconf( int name ) { 109ca0: 55 push %ebp <== NOT EXECUTED 109ca1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109ca3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED switch (name) { 109ca6: 83 7d 08 04 cmpl $0x4,0x8(%ebp) <== NOT EXECUTED 109caa: 74 38 je 109ce4 <== NOT EXECUTED 109cac: 7e 16 jle 109cc4 <== NOT EXECUTED 109cae: 83 7d 08 08 cmpl $0x8,0x8(%ebp) <== NOT EXECUTED 109cb2: 74 28 je 109cdc <== NOT EXECUTED 109cb4: 83 7d 08 33 cmpl $0x33,0x8(%ebp) <== NOT EXECUTED 109cb8: 75 10 jne 109cca <== NOT EXECUTED 109cba: b8 00 04 00 00 mov $0x400,%eax <== NOT EXECUTED default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 109cbf: c9 leave <== NOT EXECUTED 109cc0: c3 ret <== NOT EXECUTED 109cc1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED long sysconf( int name ) { switch (name) { 109cc4: 83 7d 08 02 cmpl $0x2,0x8(%ebp) <== NOT EXECUTED 109cc8: 74 22 je 109cec <== NOT EXECUTED default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 109cca: e8 e5 74 00 00 call 1111b4 <__errno> <== NOT EXECUTED 109ccf: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 109cd5: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 109cda: c9 leave <== NOT EXECUTED 109cdb: c3 ret <== NOT EXECUTED long sysconf( int name ) { switch (name) { 109cdc: b8 00 10 00 00 mov $0x1000,%eax <== NOT EXECUTED default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 109ce1: c9 leave <== NOT EXECUTED 109ce2: c3 ret <== NOT EXECUTED 109ce3: 90 nop <== NOT EXECUTED switch (name) { case _SC_CLK_TCK: return (TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick); case _SC_OPEN_MAX: { return rtems_libio_number_iops; 109ce4: a1 a0 d5 11 00 mov 0x11d5a0,%eax <== NOT EXECUTED default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 109ce9: c9 leave <== NOT EXECUTED 109cea: c3 ret <== NOT EXECUTED 109ceb: 90 nop <== NOT EXECUTED ) { switch (name) { case _SC_CLK_TCK: return (TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick); 109cec: b8 40 42 0f 00 mov $0xf4240,%eax <== NOT EXECUTED 109cf1: 31 d2 xor %edx,%edx <== NOT EXECUTED 109cf3: f7 35 20 1e 12 00 divl 0x121e20 <== NOT EXECUTED default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 109cf9: c9 leave <== NOT EXECUTED 109cfa: c3 ret <== NOT EXECUTED 0010ead8 : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 10ead8: 55 push %ebp <== NOT EXECUTED 10ead9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10eadb: 57 push %edi <== NOT EXECUTED 10eadc: 56 push %esi <== NOT EXECUTED 10eadd: 53 push %ebx <== NOT EXECUTED 10eade: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10eae1: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10eae4: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 10eae7: 83 7d 08 01 cmpl $0x1,0x8(%ebp) <== NOT EXECUTED 10eaeb: 0f 85 db 00 00 00 jne 10ebcc <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !timerid ) 10eaf1: 85 ff test %edi,%edi <== NOT EXECUTED 10eaf3: 0f 84 d3 00 00 00 je 10ebcc <== NOT EXECUTED /* * The data of the structure evp are checked in order to verify if they * are coherent. */ if (evp != NULL) { 10eaf9: 85 f6 test %esi,%esi <== NOT EXECUTED 10eafb: 74 21 je 10eb1e <== NOT EXECUTED /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 10eafd: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10eaff: 48 dec %eax <== NOT EXECUTED 10eb00: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10eb03: 0f 87 c3 00 00 00 ja 10ebcc <== NOT EXECUTED ( evp->sigev_notify != SIGEV_SIGNAL ) ) { /* The value of the field sigev_notify is not valid */ rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !evp->sigev_signo ) 10eb09: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10eb0c: 85 c0 test %eax,%eax <== NOT EXECUTED 10eb0e: 0f 84 b8 00 00 00 je 10ebcc <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 10eb14: 48 dec %eax <== NOT EXECUTED 10eb15: 83 f8 1f cmp $0x1f,%eax <== NOT EXECUTED 10eb18: 0f 87 ae 00 00 00 ja 10ebcc <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10eb1e: a1 58 7c 12 00 mov 0x127c58,%eax <== NOT EXECUTED 10eb23: 40 inc %eax <== NOT EXECUTED 10eb24: a3 58 7c 12 00 mov %eax,0x127c58 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** * This routine initializes @a the_heap record to manage the 10eb29: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10eb2c: 68 e0 7f 12 00 push $0x127fe0 <== NOT EXECUTED 10eb31: e8 c6 1d 00 00 call 1108fc <_Objects_Allocate> <== NOT EXECUTED 10eb36: 89 c3 mov %eax,%ebx <== NOT EXECUTED /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 10eb38: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eb3b: 85 c0 test %eax,%eax <== NOT EXECUTED 10eb3d: 0f 84 a1 00 00 00 je 10ebe4 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EAGAIN ); } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 10eb43: c6 40 3c 02 movb $0x2,0x3c(%eax) <== NOT EXECUTED ptimer->thread_id = _Thread_Executing->Object.id; 10eb47: a1 1c 7d 12 00 mov 0x127d1c,%eax <== NOT EXECUTED 10eb4c: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10eb4f: 89 43 38 mov %eax,0x38(%ebx) <== NOT EXECUTED if ( evp != NULL ) { 10eb52: 85 f6 test %esi,%esi <== NOT EXECUTED 10eb54: 74 11 je 10eb67 <== NOT EXECUTED ptimer->inf.sigev_notify = evp->sigev_notify; 10eb56: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10eb58: 89 43 40 mov %eax,0x40(%ebx) <== NOT EXECUTED ptimer->inf.sigev_signo = evp->sigev_signo; 10eb5b: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10eb5e: 89 43 44 mov %eax,0x44(%ebx) <== NOT EXECUTED ptimer->inf.sigev_value = evp->sigev_value; 10eb61: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10eb64: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED } ptimer->overrun = 0; 10eb67: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) <== NOT EXECUTED ptimer->timer_data.it_value.tv_sec = 0; 10eb6e: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED ptimer->timer_data.it_value.tv_nsec = 0; 10eb75: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED ptimer->timer_data.it_interval.tv_sec = 0; 10eb7c: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED ptimer->timer_data.it_interval.tv_nsec = 0; 10eb83: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED * 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. * 10eb8a: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10eb91: 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 10eb98: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx) <== NOT EXECUTED * the heap 10eb9f: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED 10eba6: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10eba9: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10ebac: a1 fc 7f 12 00 mov 0x127ffc,%eax <== NOT EXECUTED 10ebb1: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10ebb4: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL ); _Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0); *timerid = ptimer->Object.id; 10ebbb: 89 0f mov %ecx,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10ebbd: e8 c6 2a 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ebc2: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10ebc4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ebc7: 5b pop %ebx <== NOT EXECUTED 10ebc8: 5e pop %esi <== NOT EXECUTED 10ebc9: 5f pop %edi <== NOT EXECUTED 10ebca: c9 leave <== NOT EXECUTED 10ebcb: c3 ret <== NOT EXECUTED if ( !evp->sigev_signo ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) rtems_set_errno_and_return_minus_one( EINVAL ); 10ebcc: e8 7b 79 00 00 call 11654c <__errno> <== NOT EXECUTED 10ebd1: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10ebd7: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED _Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0); *timerid = ptimer->Object.id; _Thread_Enable_dispatch(); return 0; } 10ebdc: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ebdf: 5b pop %ebx <== NOT EXECUTED 10ebe0: 5e pop %esi <== NOT EXECUTED 10ebe1: 5f pop %edi <== NOT EXECUTED 10ebe2: c9 leave <== NOT EXECUTED 10ebe3: c3 ret <== NOT EXECUTED /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { _Thread_Enable_dispatch(); 10ebe4: e8 9f 2a 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EAGAIN ); 10ebe9: e8 5e 79 00 00 call 11654c <__errno> <== NOT EXECUTED 10ebee: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10ebf4: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ebf9: eb c9 jmp 10ebc4 <== NOT EXECUTED 0010a314 : int timer_delete( timer_t timerid ) { 10a314: 55 push %ebp <== NOT EXECUTED 10a315: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a317: 53 push %ebx <== NOT EXECUTED 10a318: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size 10a31b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a31e: 50 push %eax <== NOT EXECUTED 10a31f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a322: 68 80 2e 12 00 push $0x122e80 <== NOT EXECUTED 10a327: e8 f4 22 00 00 call 10c620 <_Objects_Get> <== NOT EXECUTED 10a32c: 89 c3 mov %eax,%ebx <== NOT EXECUTED */ POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 10a32e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a331: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 10a334: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a336: 74 18 je 10a350 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10a338: e8 df 7a 00 00 call 111e1c <__errno> <== NOT EXECUTED 10a33d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10a343: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 10a348: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a34b: c9 leave <== NOT EXECUTED 10a34c: c3 ret <== NOT EXECUTED 10a34d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { case OBJECTS_LOCAL: _Objects_Close( &_POSIX_Timer_Information, &ptimer->Object ); 10a350: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a353: 50 push %eax <== NOT EXECUTED 10a354: 68 80 2e 12 00 push $0x122e80 <== NOT EXECUTED 10a359: e8 4e 1e 00 00 call 10c1ac <_Objects_Close> <== NOT EXECUTED ptimer->state = POSIX_TIMER_STATE_FREE; 10a35e: c6 43 3c 01 movb $0x1,0x3c(%ebx) <== NOT EXECUTED (void) _Watchdog_Remove( &ptimer->Timer ); 10a362: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10a365: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10a368: e8 07 3c 00 00 call 10df74 <_Watchdog_Remove> <== 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, 10a36d: 58 pop %eax <== NOT EXECUTED 10a36e: 5a pop %edx <== NOT EXECUTED 10a36f: 53 push %ebx <== NOT EXECUTED 10a370: 68 80 2e 12 00 push $0x122e80 <== NOT EXECUTED 10a375: e8 72 21 00 00 call 10c4ec <_Objects_Free> <== NOT EXECUTED _POSIX_Timer_Free( ptimer ); _Thread_Enable_dispatch(); 10a37a: e8 e5 2a 00 00 call 10ce64 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a37f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a381: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10a384: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a387: c9 leave <== NOT EXECUTED 10a388: c3 ret <== NOT EXECUTED 0010b4b8 : * its execution, _POSIX_Timer_TSR will have to set this counter to 0. */ int timer_getoverrun( timer_t timerid ) { 10b4b8: 55 push %ebp <== NOT EXECUTED 10b4b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4bb: 53 push %ebx <== NOT EXECUTED 10b4bc: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size 10b4bf: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10b4c2: 50 push %eax <== NOT EXECUTED 10b4c3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b4c6: 68 c0 41 12 00 push $0x1241c0 <== NOT EXECUTED 10b4cb: e8 7c 22 00 00 call 10d74c <_Objects_Get> <== NOT EXECUTED int overrun; POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 10b4d0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b4d3: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10b4d6: 85 d2 test %edx,%edx <== NOT EXECUTED 10b4d8: 74 1a je 10b4f4 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10b4da: e8 b9 76 00 00 call 112b98 <__errno> <== NOT EXECUTED 10b4df: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b4e5: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED } 10b4ea: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b4ec: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b4ef: c9 leave <== NOT EXECUTED 10b4f0: c3 ret <== NOT EXECUTED 10b4f1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { case OBJECTS_LOCAL: overrun = ptimer->overrun; 10b4f4: 8b 58 68 mov 0x68(%eax),%ebx <== NOT EXECUTED ptimer->overrun = 0; 10b4f7: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10b4fe: e8 8d 2a 00 00 call 10df90 <_Thread_Enable_dispatch> <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10b503: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b505: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b508: c9 leave <== NOT EXECUTED 10b509: c3 ret <== NOT EXECUTED 0010b50c : int timer_gettime( timer_t timerid, struct itimerspec *value ) { 10b50c: 55 push %ebp <== NOT EXECUTED 10b50d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b50f: 56 push %esi <== NOT EXECUTED 10b510: 53 push %ebx <== NOT EXECUTED 10b511: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10b514: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED POSIX_Timer_Control *ptimer; Objects_Locations location; struct timespec current_time; Watchdog_Interval left; if ( !value ) 10b517: 85 f6 test %esi,%esi <== NOT EXECUTED 10b519: 74 65 je 10b580 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); /* Reads the current time */ _TOD_Get( ¤t_time ); 10b51b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b51e: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10b521: 50 push %eax <== NOT EXECUTED 10b522: e8 b9 19 00 00 call 10cee0 <_TOD_Get> <== NOT EXECUTED 10b527: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10b52a: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10b52d: 50 push %eax <== NOT EXECUTED 10b52e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b531: 68 c0 41 12 00 push $0x1241c0 <== NOT EXECUTED 10b536: e8 11 22 00 00 call 10d74c <_Objects_Get> <== NOT EXECUTED 10b53b: 89 c3 mov %eax,%ebx <== NOT EXECUTED ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 10b53d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b540: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 10b543: 85 c0 test %eax,%eax <== NOT EXECUTED 10b545: 75 39 jne 10b580 <== NOT EXECUTED case OBJECTS_LOCAL: /* Calculates the time left before the timer finishes */ left = 10b547: 8b 15 a4 3f 12 00 mov 0x123fa4,%edx <== NOT EXECUTED (ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */ _Watchdog_Ticks_since_boot; /* now */ _Timespec_From_ticks( left, &value->it_value ); 10b54d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b550: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED 10b553: 50 push %eax <== NOT EXECUTED 10b554: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10b557: 03 43 24 add 0x24(%ebx),%eax <== NOT EXECUTED 10b55a: 29 d0 sub %edx,%eax <== NOT EXECUTED 10b55c: 50 push %eax <== NOT EXECUTED 10b55d: e8 96 36 00 00 call 10ebf8 <_Timespec_From_ticks> <== NOT EXECUTED value->it_interval = ptimer->timer_data.it_interval; 10b562: 8b 53 54 mov 0x54(%ebx),%edx <== NOT EXECUTED 10b565: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED 10b568: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 10b56b: 89 16 mov %edx,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10b56d: e8 1e 2a 00 00 call 10df90 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b572: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b574: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10b577: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b57a: 5b pop %ebx <== NOT EXECUTED 10b57b: 5e pop %esi <== NOT EXECUTED 10b57c: c9 leave <== NOT EXECUTED 10b57d: c3 ret <== NOT EXECUTED 10b57e: 66 90 xchg %ax,%ax <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10b580: e8 13 76 00 00 call 112b98 <__errno> <== NOT EXECUTED 10b585: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b58b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10b590: eb e5 jmp 10b577 <== NOT EXECUTED 0010b594 : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 10b594: 55 push %ebp <== NOT EXECUTED 10b595: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b597: 57 push %edi <== NOT EXECUTED 10b598: 56 push %esi <== NOT EXECUTED 10b599: 53 push %ebx <== NOT EXECUTED 10b59a: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED Objects_Locations location; bool activated; uint32_t initial_period; struct itimerspec normalize; if ( !value ) 10b59d: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b5a0: 85 c0 test %eax,%eax <== NOT EXECUTED 10b5a2: 0f 84 04 01 00 00 je 10b6ac <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); /* First, it verifies if the structure "value" is correct */ if ( ( value->it_value.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) || 10b5a8: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b5ab: 81 78 0c ff c9 9a 3b cmpl $0x3b9ac9ff,0xc(%eax) <== NOT EXECUTED 10b5b2: 0f 87 f4 00 00 00 ja 10b6ac <== NOT EXECUTED 10b5b8: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10b5bb: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 10b5c0: 0f 87 e6 00 00 00 ja 10b6ac <== NOT EXECUTED 10b5c6: 85 c0 test %eax,%eax <== NOT EXECUTED 10b5c8: 0f 88 de 00 00 00 js 10b6ac <== NOT EXECUTED ( value->it_interval.tv_nsec < 0 )) { /* The number of nanoseconds is not correct */ rtems_set_errno_and_return_minus_one( EINVAL ); } if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 10b5ce: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) <== NOT EXECUTED 10b5d2: 0f 84 2c 01 00 00 je 10b704 <== NOT EXECUTED 10b5d8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b5db: 85 c0 test %eax,%eax <== NOT EXECUTED 10b5dd: 0f 85 c9 00 00 00 jne 10b6ac <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 10b5e3: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 10b5e6: 89 45 b8 mov %eax,-0x48(%ebp) <== NOT EXECUTED 10b5e9: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10b5ee: 89 c7 mov %eax,%edi <== NOT EXECUTED 10b5f0: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10b5f3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10b5f5: 50 push %eax <== NOT EXECUTED 10b5f6: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b5f9: 50 push %eax <== NOT EXECUTED 10b5fa: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b5fd: 68 c0 41 12 00 push $0x1241c0 <== NOT EXECUTED 10b602: e8 45 21 00 00 call 10d74c <_Objects_Get> <== NOT EXECUTED 10b607: 89 c3 mov %eax,%ebx <== NOT EXECUTED * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 10b609: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b60c: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 10b60f: 85 ff test %edi,%edi <== NOT EXECUTED 10b611: 0f 85 95 00 00 00 jne 10b6ac <== NOT EXECUTED case OBJECTS_LOCAL: /* First, it verifies if the timer must be stopped */ if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) { 10b617: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 10b61a: 85 f6 test %esi,%esi <== NOT EXECUTED 10b61c: 75 0b jne 10b629 <== NOT EXECUTED 10b61e: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 10b621: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b623: 0f 84 9b 00 00 00 je 10b6c4 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* Convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); 10b629: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b62c: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10b62f: e8 6c 36 00 00 call 10eca0 <_Timespec_To_ticks> <== NOT EXECUTED 10b634: 89 43 64 mov %eax,0x64(%ebx) <== NOT EXECUTED initial_period = _Timespec_To_ticks( &normalize.it_value ); 10b637: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10b63a: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10b63d: e8 5e 36 00 00 call 10eca0 <_Timespec_To_ticks> <== NOT EXECUTED activated = _POSIX_Timer_Insert_helper( 10b642: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10b645: 68 60 b7 10 00 push $0x10b760 <== NOT EXECUTED 10b64a: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10b64d: 50 push %eax <== NOT EXECUTED 10b64e: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10b651: 50 push %eax <== NOT EXECUTED 10b652: e8 b5 5b 00 00 call 11120c <_POSIX_Timer_Insert_helper> <== NOT EXECUTED initial_period, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 10b657: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10b65a: 84 c0 test %al,%al <== NOT EXECUTED 10b65c: 0f 84 e2 00 00 00 je 10b744 <== NOT EXECUTED /* * The timer has been started and is running. So we return the * old ones in "ovalue" */ if ( ovalue ) 10b662: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10b665: 85 c0 test %eax,%eax <== NOT EXECUTED 10b667: 0f 84 e3 00 00 00 je 10b750 <== NOT EXECUTED *ovalue = ptimer->timer_data; 10b66d: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10b670: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10b675: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 10b678: 89 c6 mov %eax,%esi <== NOT EXECUTED 10b67a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED ptimer->timer_data = normalize; 10b67c: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10b681: 89 c7 mov %eax,%edi <== NOT EXECUTED 10b683: 8b 75 b8 mov -0x48(%ebp),%esi <== NOT EXECUTED 10b686: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10b688: c6 43 3c 03 movb $0x3,0x3c(%ebx) <== NOT EXECUTED _TOD_Get( &ptimer->time ); 10b68c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b68f: 8d 43 6c lea 0x6c(%ebx),%eax <== NOT EXECUTED 10b692: 50 push %eax <== NOT EXECUTED 10b693: e8 48 18 00 00 call 10cee0 <_TOD_Get> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b698: e8 f3 28 00 00 call 10df90 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b69d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b69f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10b6a2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b6a5: 5b pop %ebx <== NOT EXECUTED 10b6a6: 5e pop %esi <== NOT EXECUTED 10b6a7: 5f pop %edi <== NOT EXECUTED 10b6a8: c9 leave <== NOT EXECUTED 10b6a9: c3 ret <== NOT EXECUTED 10b6aa: 66 90 xchg %ax,%ax <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10b6ac: e8 e7 74 00 00 call 112b98 <__errno> <== NOT EXECUTED 10b6b1: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b6b7: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 10b6bc: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b6bf: 5b pop %ebx <== NOT EXECUTED 10b6c0: 5e pop %esi <== NOT EXECUTED 10b6c1: 5f pop %edi <== NOT EXECUTED 10b6c2: c9 leave <== NOT EXECUTED 10b6c3: c3 ret <== NOT EXECUTED case OBJECTS_LOCAL: /* First, it verifies if the timer must be stopped */ if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) { /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 10b6c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b6c7: 8d 40 10 lea 0x10(%eax),%eax <== NOT EXECUTED 10b6ca: 50 push %eax <== NOT EXECUTED 10b6cb: e8 0c 3a 00 00 call 10f0dc <_Watchdog_Remove> <== NOT EXECUTED /* The old data of the timer are returned */ if ( ovalue ) 10b6d0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b6d3: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10b6d6: 85 d2 test %edx,%edx <== NOT EXECUTED 10b6d8: 74 7e je 10b758 <== NOT EXECUTED *ovalue = ptimer->timer_data; 10b6da: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10b6dd: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10b6e2: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 10b6e5: 89 c6 mov %eax,%esi <== NOT EXECUTED 10b6e7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* The new data are set */ ptimer->timer_data = normalize; 10b6e9: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10b6ee: 89 c7 mov %eax,%edi <== NOT EXECUTED 10b6f0: 8b 75 b8 mov -0x48(%ebp),%esi <== NOT EXECUTED 10b6f3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10b6f5: c6 43 3c 04 movb $0x4,0x3c(%ebx) <== NOT EXECUTED /* Returns with success */ _Thread_Enable_dispatch(); 10b6f9: e8 92 28 00 00 call 10df90 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b6fe: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b700: eb ba jmp 10b6bc <== NOT EXECUTED 10b702: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 10b704: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED 10b707: 89 75 b8 mov %esi,-0x48(%ebp) <== NOT EXECUTED 10b70a: 89 f7 mov %esi,%edi <== NOT EXECUTED 10b70c: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10b70f: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10b712: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { /* Check for seconds in the past */ if ( _Timespec_Greater_than( &_TOD_Now, &normalize.it_value ) ) 10b714: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b717: 8d 5d e8 lea -0x18(%ebp),%ebx <== NOT EXECUTED 10b71a: 53 push %ebx <== NOT EXECUTED 10b71b: 68 cc 3e 12 00 push $0x123ecc <== NOT EXECUTED 10b720: e8 1b 35 00 00 call 10ec40 <_Timespec_Greater_than> <== NOT EXECUTED 10b725: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b728: 84 c0 test %al,%al <== NOT EXECUTED 10b72a: 75 80 jne 10b6ac <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_Subtract( &_TOD_Now, &normalize.it_value, &normalize.it_value ); 10b72c: 50 push %eax <== NOT EXECUTED 10b72d: 53 push %ebx <== NOT EXECUTED 10b72e: 53 push %ebx <== NOT EXECUTED 10b72f: 68 cc 3e 12 00 push $0x123ecc <== NOT EXECUTED 10b734: e8 2b 35 00 00 call 10ec64 <_Timespec_Subtract> <== NOT EXECUTED 10b739: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b73c: e9 b4 fe ff ff jmp 10b5f5 <== NOT EXECUTED 10b741: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { _Thread_Enable_dispatch(); 10b744: e8 47 28 00 00 call 10df90 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b749: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b74b: e9 6c ff ff ff jmp 10b6bc <== NOT EXECUTED 10b750: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10b753: e9 24 ff ff ff jmp 10b67c <== NOT EXECUTED 10b758: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10b75b: eb 8c jmp 10b6e9 <== NOT EXECUTED 00109f50 : useconds_t ualarm( useconds_t useconds, useconds_t interval ) { 109f50: 55 push %ebp <== NOT EXECUTED 109f51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109f53: 57 push %edi <== NOT EXECUTED 109f54: 56 push %esi <== NOT EXECUTED 109f55: 53 push %ebx <== NOT EXECUTED 109f56: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 109f59: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 109f5c: 8b 0d bc 21 12 00 mov 0x1221bc,%ecx <== NOT EXECUTED 109f62: 85 c9 test %ecx,%ecx <== NOT EXECUTED 109f64: 0f 84 ea 00 00 00 je 10a054 <== NOT EXECUTED _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { switch ( _Watchdog_Remove( the_timer ) ) { 109f6a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109f6d: 68 a0 21 12 00 push $0x1221a0 <== NOT EXECUTED 109f72: e8 dd 3a 00 00 call 10da54 <_Watchdog_Remove> <== NOT EXECUTED 109f77: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109f7a: 83 e8 02 sub $0x2,%eax <== NOT EXECUTED 109f7d: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 109f80: 76 72 jbe 109ff4 <== NOT EXECUTED 109f82: 31 ff xor %edi,%edi <== NOT EXECUTED /* * If useconds is non-zero, then the caller wants to schedule * the alarm repeatedly at that interval. If the interval is * less than a single clock tick, then fudge it to a clock tick. */ if ( useconds ) { 109f84: 85 f6 test %esi,%esi <== NOT EXECUTED 109f86: 74 62 je 109fea <== NOT EXECUTED Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 109f88: ba 83 de 1b 43 mov $0x431bde83,%edx <== NOT EXECUTED 109f8d: 89 f0 mov %esi,%eax <== NOT EXECUTED 109f8f: f7 e2 mul %edx <== NOT EXECUTED 109f91: c1 ea 12 shr $0x12,%edx <== NOT EXECUTED 109f94: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 109f97: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 109f9a: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 109f9d: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 109fa0: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 109fa3: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 109fa6: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 109fa9: c1 e2 06 shl $0x6,%edx <== NOT EXECUTED 109fac: 29 d6 sub %edx,%esi <== NOT EXECUTED 109fae: 8d 04 b6 lea (%esi,%esi,4),%eax <== NOT EXECUTED 109fb1: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 109fb4: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 109fb7: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED 109fba: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED ticks = _Timespec_To_ticks( &tp ); 109fbd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109fc0: 8d 5d e8 lea -0x18(%ebp),%ebx <== NOT EXECUTED 109fc3: 53 push %ebx <== NOT EXECUTED 109fc4: e8 0f 36 00 00 call 10d5d8 <_Timespec_To_ticks> <== NOT EXECUTED if ( ticks == 0 ) ticks = 1; _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) ); 109fc9: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 109fcc: e8 07 36 00 00 call 10d5d8 <_Timespec_To_ticks> <== 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, 109fd1: a3 ac 21 12 00 mov %eax,0x1221ac <== NOT EXECUTED void *starting_address, size_t *size 109fd6: 58 pop %eax <== NOT EXECUTED 109fd7: 5a pop %edx <== NOT EXECUTED 109fd8: 68 a0 21 12 00 push $0x1221a0 <== NOT EXECUTED 109fdd: 68 7c 23 12 00 push $0x12237c <== NOT EXECUTED 109fe2: e8 3d 39 00 00 call 10d924 <_Watchdog_Insert> <== NOT EXECUTED 109fe7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return remaining; } 109fea: 89 f8 mov %edi,%eax <== NOT EXECUTED 109fec: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109fef: 5b pop %ebx <== NOT EXECUTED 109ff0: 5e pop %esi <== NOT EXECUTED 109ff1: 5f pop %edi <== NOT EXECUTED 109ff2: c9 leave <== NOT EXECUTED 109ff3: c3 ret <== NOT EXECUTED * boot. Since alarm() is dealing in seconds, we must account for * this. */ ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); 109ff4: a1 b4 21 12 00 mov 0x1221b4,%eax <== NOT EXECUTED 109ff9: 03 05 ac 21 12 00 add 0x1221ac,%eax <== NOT EXECUTED /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 109fff: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a002: 8d 55 e8 lea -0x18(%ebp),%edx <== NOT EXECUTED 10a005: 52 push %edx <== NOT EXECUTED 10a006: 2b 05 b8 21 12 00 sub 0x1221b8,%eax <== NOT EXECUTED 10a00c: 50 push %eax <== NOT EXECUTED 10a00d: e8 42 35 00 00 call 10d554 <_Timespec_From_ticks> <== NOT EXECUTED remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 10a012: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10a015: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10a018: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10a01b: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10a01e: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10a021: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10a024: 8d 3c 80 lea (%eax,%eax,4),%edi <== NOT EXECUTED 10a027: c1 e7 06 shl $0x6,%edi <== NOT EXECUTED remaining += tp.tv_nsec / 1000; 10a02a: 8b 5d ec mov -0x14(%ebp),%ebx <== NOT EXECUTED 10a02d: b9 d3 4d 62 10 mov $0x10624dd3,%ecx <== NOT EXECUTED 10a032: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a034: f7 e9 imul %ecx <== NOT EXECUTED 10a036: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED 10a039: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED 10a03c: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 10a03f: c1 fa 06 sar $0x6,%edx <== NOT EXECUTED 10a042: c1 fb 1f sar $0x1f,%ebx <== NOT EXECUTED 10a045: 29 da sub %ebx,%edx <== NOT EXECUTED 10a047: 8d 3c 3a lea (%edx,%edi,1),%edi <== NOT EXECUTED 10a04a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a04d: e9 32 ff ff ff jmp 109f84 <== NOT EXECUTED 10a052: 66 90 xchg %ax,%ax <== 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. * 10a054: c7 05 a8 21 12 00 00 movl $0x0,0x1221a8 <== NOT EXECUTED 10a05b: 00 00 00 <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10a05e: c7 05 bc 21 12 00 84 movl $0x10a084,0x1221bc <== NOT EXECUTED 10a065: a0 10 00 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10a068: c7 05 c0 21 12 00 00 movl $0x0,0x1221c0 <== NOT EXECUTED 10a06f: 00 00 00 <== NOT EXECUTED * the heap 10a072: c7 05 c4 21 12 00 00 movl $0x0,0x1221c4 <== NOT EXECUTED 10a079: 00 00 00 <== NOT EXECUTED 10a07c: 31 ff xor %edi,%edi <== NOT EXECUTED 10a07e: e9 01 ff ff ff jmp 109f84 <== NOT EXECUTED 0010e53c : int usleep( useconds_t useconds ) { 10e53c: 55 push %ebp <== NOT EXECUTED 10e53d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e53f: 57 push %edi <== NOT EXECUTED 10e540: 56 push %esi <== NOT EXECUTED 10e541: 53 push %ebx <== NOT EXECUTED 10e542: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 10e545: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED struct timespec tp; struct timespec tm; unsigned remaining; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 10e548: ba 83 de 1b 43 mov $0x431bde83,%edx <== NOT EXECUTED 10e54d: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10e54f: f7 e2 mul %edx <== NOT EXECUTED 10e551: c1 ea 12 shr $0x12,%edx <== NOT EXECUTED 10e554: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 10e557: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e55a: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e55d: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e560: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e563: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e566: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e569: c1 e2 06 shl $0x6,%edx <== NOT EXECUTED 10e56c: 29 d1 sub %edx,%ecx <== NOT EXECUTED 10e56e: 8d 04 89 lea (%ecx,%ecx,4),%eax <== NOT EXECUTED 10e571: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10e574: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10e577: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED 10e57a: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED nanosleep( &tp, &tm ); 10e57d: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10e580: 50 push %eax <== NOT EXECUTED 10e581: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10e584: 50 push %eax <== NOT EXECUTED 10e585: e8 1e 73 00 00 call 1158a8 <== NOT EXECUTED remaining = tm.tv_sec * TOD_MICROSECONDS_PER_SECOND; 10e58a: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10e58d: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e590: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e593: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e596: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e599: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e59c: 8d 3c 92 lea (%edx,%edx,4),%edi <== NOT EXECUTED 10e59f: c1 e7 06 shl $0x6,%edi <== NOT EXECUTED 10e5a2: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 10e5a5: b9 d3 4d 62 10 mov $0x10624dd3,%ecx <== NOT EXECUTED 10e5aa: 89 f0 mov %esi,%eax <== NOT EXECUTED 10e5ac: f7 e9 imul %ecx <== NOT EXECUTED 10e5ae: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e5b0: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 10e5b3: c1 fe 1f sar $0x1f,%esi <== NOT EXECUTED 10e5b6: 29 f0 sub %esi,%eax <== NOT EXECUTED 10e5b8: 01 f8 add %edi,%eax <== NOT EXECUTED remaining += tm.tv_nsec / 1000; return remaining; /* seconds remaining */ } 10e5ba: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e5bd: 5b pop %ebx <== NOT EXECUTED 10e5be: 5e pop %esi <== NOT EXECUTED 10e5bf: 5f pop %edi <== NOT EXECUTED 10e5c0: c9 leave <== NOT EXECUTED 10e5c1: c3 ret <== NOT EXECUTED 0010a4ac : #include int wait( int *stat_loc ) { 10a4ac: 55 push %ebp <== NOT EXECUTED 10a4ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4af: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a4b2: e8 c9 75 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a4b7: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a4bd: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a4c2: c9 leave <== NOT EXECUTED 10a4c3: c3 ret <== NOT EXECUTED 0010a4c4 : int waitpid( pid_t pid, int *stat_loc, int options ) { 10a4c4: 55 push %ebp <== NOT EXECUTED 10a4c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4c7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a4ca: e8 b1 75 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a4cf: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a4d5: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a4da: c9 leave <== NOT EXECUTED 10a4db: c3 ret <== NOT EXECUTED