=============================================================================== 0010dee0 <_Signal_Action_handler>: void _Signal_Action_handler( Thread_Control *executing, Thread_Action *action, ISR_lock_Context *lock_context ) { 10dee0: 55 push %ebp 10dee1: 89 e5 mov %esp,%ebp 10dee3: 83 ec 38 sub $0x38,%esp 10dee6: 89 5d f4 mov %ebx,-0xc(%ebp) /* * Signal Processing */ api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10dee9: 8b 45 08 mov 0x8(%ebp),%eax { 10deec: 89 75 f8 mov %esi,-0x8(%ebp) 10deef: 89 7d fc mov %edi,-0x4(%ebp) api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10def2: 8b 98 08 01 00 00 mov 0x108(%eax),%ebx ASR_Information *asr ) { rtems_signal_set signal_set; signal_set = asr->signals_posted; 10def8: 8b 73 14 mov 0x14(%ebx),%esi asr->signals_posted = 0; 10defb: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) _ISR_lock_ISR_enable( lock_context ); 10df02: 8b 45 10 mov 0x10(%ebp),%eax 10df05: ff 30 push (%eax) 10df07: 9d popf asr = &api->Signal; signal_set = _ASR_Get_posted_signals( asr ); _Thread_State_release( executing, lock_context ); if ( signal_set == 0 ) { 10df08: 85 f6 test %esi,%esi 10df0a: 74 3f je 10df4b <_Signal_Action_handler+0x6b> <== NEVER TAKEN return; } asr->nest_level += 1; rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10df0c: 8d 7d e4 lea -0x1c(%ebp),%edi 10df0f: b8 ff ff 00 00 mov $0xffff,%eax asr->nest_level += 1; 10df14: ff 43 1c incl 0x1c(%ebx) rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10df17: 89 7c 24 08 mov %edi,0x8(%esp) 10df1b: 89 44 24 04 mov %eax,0x4(%esp) 10df1f: 8b 43 10 mov 0x10(%ebx),%eax 10df22: 89 04 24 mov %eax,(%esp) 10df25: e8 c6 93 ff ff call 1072f0 (*asr->handler)( signal_set ); 10df2a: 89 34 24 mov %esi,(%esp) 10df2d: ff 53 0c call *0xc(%ebx) asr->nest_level -= 1; rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10df30: 8b 45 e4 mov -0x1c(%ebp),%eax 10df33: ba ff ff 00 00 mov $0xffff,%edx asr->nest_level -= 1; 10df38: ff 4b 1c decl 0x1c(%ebx) rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10df3b: 89 7c 24 08 mov %edi,0x8(%esp) 10df3f: 89 54 24 04 mov %edx,0x4(%esp) 10df43: 89 04 24 mov %eax,(%esp) 10df46: e8 a5 93 ff ff call 1072f0 } 10df4b: 8b 5d f4 mov -0xc(%ebp),%ebx 10df4e: 8b 75 f8 mov -0x8(%ebp),%esi 10df51: 8b 7d fc mov -0x4(%ebp),%edi 10df54: 89 ec mov %ebp,%esp 10df56: 5d pop %ebp 10df57: c3 ret 10df58: 90 nop 10df59: 90 nop 10df5a: 90 nop 10df5b: 90 nop 10df5c: 90 nop 10df5d: 90 nop 10df5e: 90 nop 10df5f: 90 nop =============================================================================== 00104f20 <_TOD_Validate>: }; bool _TOD_Validate( const rtems_time_of_day *the_tod ) { 104f20: 55 push %ebp uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 104f21: 31 d2 xor %edx,%edx { 104f23: 89 e5 mov %esp,%ebp ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 104f25: b8 40 42 0f 00 mov $0xf4240,%eax 104f2a: f7 35 78 25 12 00 divl 0x122578 { 104f30: 8b 4d 08 mov 0x8(%ebp),%ecx 104f33: 53 push %ebx rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 104f34: 85 c9 test %ecx,%ecx 104f36: 74 58 je 104f90 <_TOD_Validate+0x70> <== NEVER TAKEN 104f38: 39 41 18 cmp %eax,0x18(%ecx) 104f3b: 73 53 jae 104f90 <_TOD_Validate+0x70> (the_tod->ticks >= ticks_per_second) || 104f3d: 83 79 14 3b cmpl $0x3b,0x14(%ecx) 104f41: 77 4d ja 104f90 <_TOD_Validate+0x70> (the_tod->second >= TOD_SECONDS_PER_MINUTE) || 104f43: 83 79 10 3b cmpl $0x3b,0x10(%ecx) 104f47: 77 47 ja 104f90 <_TOD_Validate+0x70> (the_tod->minute >= TOD_MINUTES_PER_HOUR) || 104f49: 83 79 0c 17 cmpl $0x17,0xc(%ecx) 104f4d: 77 41 ja 104f90 <_TOD_Validate+0x70> (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || 104f4f: 8b 51 04 mov 0x4(%ecx),%edx (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) return false; 104f52: 31 c0 xor %eax,%eax (the_tod->month == 0) || 104f54: 8d 5a ff lea -0x1(%edx),%ebx 104f57: 83 fb 0b cmp $0xb,%ebx 104f5a: 77 36 ja 104f92 <_TOD_Validate+0x72> (the_tod->year < TOD_BASE_YEAR) || 104f5c: 8b 19 mov (%ecx),%ebx (the_tod->month > TOD_MONTHS_PER_YEAR) || 104f5e: 81 fb c3 07 00 00 cmp $0x7c3,%ebx 104f64: 76 2c jbe 104f92 <_TOD_Validate+0x72> (the_tod->day == 0) ) 104f66: 8b 49 08 mov 0x8(%ecx),%ecx (the_tod->year < TOD_BASE_YEAR) || 104f69: 85 c9 test %ecx,%ecx 104f6b: 74 25 je 104f92 <_TOD_Validate+0x72> <== NEVER TAKEN if (((the_tod->year % 4) == 0 && (the_tod->year % 100 != 0)) || 104f6d: f6 c3 03 test $0x3,%bl 104f70: 75 2e jne 104fa0 <_TOD_Validate+0x80> 104f72: 69 c3 29 5c 8f c2 imul $0xc28f5c29,%ebx,%eax 104f78: c1 c8 02 ror $0x2,%eax 104f7b: 3d 28 5c 8f 02 cmp $0x28f5c28,%eax 104f80: 76 1e jbe 104fa0 <_TOD_Validate+0x80> (the_tod->year % 400 == 0)) days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 104f82: 8b 04 95 f4 2d 12 00 mov 0x122df4(,%edx,4),%eax else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; if ( the_tod->day > days_in_month ) 104f89: 39 c1 cmp %eax,%ecx 104f8b: 0f 96 c0 setbe %al 104f8e: eb 02 jmp 104f92 <_TOD_Validate+0x72> return false; 104f90: 31 c0 xor %eax,%eax return false; return true; } 104f92: 5b pop %ebx 104f93: 5d pop %ebp 104f94: c3 ret 104f95: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 104f9c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 104fa0: 69 db 29 5c 8f c2 imul $0xc28f5c29,%ebx,%ebx 104fa6: c1 cb 04 ror $0x4,%ebx if (((the_tod->year % 4) == 0 && (the_tod->year % 100 != 0)) || 104fa9: 81 fb 0a d7 a3 00 cmp $0xa3d70a,%ebx 104faf: 76 d1 jbe 104f82 <_TOD_Validate+0x62> days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 104fb1: 8b 04 95 c0 2d 12 00 mov 0x122dc0(,%edx,4),%eax 104fb8: eb cf jmp 104f89 <_TOD_Validate+0x69> 104fba: 90 nop 104fbb: 90 nop 104fbc: 90 nop 104fbd: 90 nop 104fbe: 90 nop 104fbf: 90 nop =============================================================================== 00104b80 : } rtems_status_code rtems_clock_get_tod( rtems_time_of_day *time_buffer ) { 104b80: 55 push %ebp 104b81: 89 e5 mov %esp,%ebp 104b83: 57 push %edi 104b84: 56 push %esi 104b85: 53 push %ebx 104b86: 83 ec 4c sub $0x4c,%esp 104b89: 8b 5d 08 mov 0x8(%ebp),%ebx uint32_t day_secs; uint32_t year; uint32_t year_days; uint32_t leap_years; if ( !time_buffer ) 104b8c: 85 db test %ebx,%ebx 104b8e: 0f 84 5c 02 00 00 je 104df0 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set() ) 104b94: 80 3d f0 bc 12 00 00 cmpb $0x0,0x12bcf0 104b9b: 0f 84 ff 01 00 00 je 104da0 */ RTEMS_INLINE_ROUTINE void _TOD_Get_timeval( struct timeval *time ) { _Timecounter_Microtime( time ); 104ba1: 8d 45 dc lea -0x24(%ebp),%eax 104ba4: 89 04 24 mov %eax,(%esp) 104ba7: e8 84 21 00 00 call 106d30 <_Timecounter_Microtime> /* Obtain the current time */ _TOD_Get_timeval( &now ); /* How many days and how many seconds in the day ? */ days = now.tv_sec / RTEMS_SECS_PER_DAY; 104bac: 8b 75 dc mov -0x24(%ebp),%esi 104baf: 31 d2 xor %edx,%edx 104bb1: 89 54 24 0c mov %edx,0xc(%esp) 104bb5: 8b 7d e0 mov -0x20(%ebp),%edi 104bb8: b8 80 51 01 00 mov $0x15180,%eax 104bbd: 89 44 24 08 mov %eax,0x8(%esp) 104bc1: 89 34 24 mov %esi,(%esp) 104bc4: 89 7c 24 04 mov %edi,0x4(%esp) 104bc8: e8 f3 40 01 00 call 118cc0 <__divdi3> day_secs = now.tv_sec % RTEMS_SECS_PER_DAY; 104bcd: b9 80 51 01 00 mov $0x15180,%ecx 104bd2: 89 4c 24 08 mov %ecx,0x8(%esp) 104bd6: 89 34 24 mov %esi,(%esp) 104bd9: 89 7c 24 04 mov %edi,0x4(%esp) days = now.tv_sec / RTEMS_SECS_PER_DAY; 104bdd: 89 45 d4 mov %eax,-0x2c(%ebp) day_secs = now.tv_sec % RTEMS_SECS_PER_DAY; 104be0: 31 c0 xor %eax,%eax 104be2: 89 44 24 0c mov %eax,0xc(%esp) 104be6: e8 45 42 01 00 call 118e30 <__moddi3> /* How many non-leap year years ? */ year = ( days / RTEMS_DAYS_PER_YEAR ) + RTEMS_YEAR_BASE; 104beb: 8b 7d d4 mov -0x2c(%ebp),%edi 104bee: 89 f9 mov %edi,%ecx day_secs = now.tv_sec % RTEMS_SECS_PER_DAY; 104bf0: 89 45 d0 mov %eax,-0x30(%ebp) year = ( days / RTEMS_DAYS_PER_YEAR ) + RTEMS_YEAR_BASE; 104bf3: b8 61 f3 19 67 mov $0x6719f361,%eax 104bf8: f7 e7 mul %edi 104bfa: 29 d1 sub %edx,%ecx 104bfc: d1 e9 shr %ecx 104bfe: 01 d1 add %edx,%ecx return (year / 4) - (year / 100) + (year / 400); 104c00: ba 1f 85 eb 51 mov $0x51eb851f,%edx year = ( days / RTEMS_DAYS_PER_YEAR ) + RTEMS_YEAR_BASE; 104c05: c1 e9 08 shr $0x8,%ecx year -= 1; 104c08: 8d b1 b1 07 00 00 lea 0x7b1(%ecx),%esi return (year / 4) - (year / 100) + (year / 400); 104c0e: 89 f0 mov %esi,%eax 104c10: f7 e2 mul %edx 104c12: 89 d0 mov %edx,%eax 104c14: c1 e8 05 shr $0x5,%eax 104c17: 89 45 cc mov %eax,-0x34(%ebp) 104c1a: c1 ea 07 shr $0x7,%edx 104c1d: 89 f0 mov %esi,%eax 104c1f: c1 e8 02 shr $0x2,%eax 104c22: 8d 94 10 23 fe ff ff lea -0x1dd(%eax,%edx,1),%edx /* Determine the number of leap years. */ leap_years = _Leap_years_between( RTEMS_YEAR_BASE, year ); /* Adjust the remaining number of days based on the leap years. */ year_days = ( days - leap_years ) % RTEMS_DAYS_PER_YEAR; 104c29: 8b 45 cc mov -0x34(%ebp),%eax 104c2c: 89 55 c8 mov %edx,-0x38(%ebp) 104c2f: 01 f8 add %edi,%eax 104c31: 89 c7 mov %eax,%edi 104c33: b8 61 f3 19 67 mov $0x6719f361,%eax 104c38: 29 d7 sub %edx,%edi 104c3a: f7 e7 mul %edi 104c3c: 89 55 c4 mov %edx,-0x3c(%ebp) 104c3f: 89 fa mov %edi,%edx 104c41: 89 45 c0 mov %eax,-0x40(%ebp) 104c44: 8b 45 c4 mov -0x3c(%ebp),%eax 104c47: 29 c2 sub %eax,%edx 104c49: 89 d0 mov %edx,%eax 104c4b: 8b 55 c4 mov -0x3c(%ebp),%edx 104c4e: d1 e8 shr %eax 104c50: 01 c2 add %eax,%edx 104c52: c1 ea 08 shr $0x8,%edx 104c55: 8d 04 d2 lea (%edx,%edx,8),%eax 104c58: 8d 04 c2 lea (%edx,%eax,8),%eax 104c5b: 89 fa mov %edi,%edx 104c5d: 8d 04 80 lea (%eax,%eax,4),%eax 104c60: 29 c2 sub %eax,%edx /* Adjust the year and days in the year if in the leap year overflow. */ if ( leap_years > ( days % RTEMS_DAYS_PER_YEAR ) ) { 104c62: 8d 04 c9 lea (%ecx,%ecx,8),%eax 104c65: 8d 04 c1 lea (%ecx,%eax,8),%eax 104c68: 8d 3c 80 lea (%eax,%eax,4),%edi 104c6b: 8b 45 d4 mov -0x2c(%ebp),%eax 104c6e: 29 f8 sub %edi,%eax return _Leap_years_before( to ) - _Leap_years_before( from + 1 ); 104c70: 8b 7d c8 mov -0x38(%ebp),%edi 104c73: 2b 7d cc sub -0x34(%ebp),%edi if ( leap_years > ( days % RTEMS_DAYS_PER_YEAR ) ) { 104c76: 39 f8 cmp %edi,%eax 104c78: 0f 82 c2 00 00 00 jb 104d40 year = ( days / RTEMS_DAYS_PER_YEAR ) + RTEMS_YEAR_BASE; 104c7e: 8d b1 b2 07 00 00 lea 0x7b2(%ecx),%esi return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0); 104c84: 89 f0 mov %esi,%eax 104c86: 83 e0 03 and $0x3,%eax if ( _Leap_year( year ) ) { year_days += 1; } } time_buffer->year = year; 104c89: 89 33 mov %esi,(%ebx) return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0); 104c8b: 85 c0 test %eax,%eax 104c8d: 0f 85 dd 00 00 00 jne 104d70 104c93: 69 c6 29 5c 8f c2 imul $0xc28f5c29,%esi,%eax days_to_date = _TOD_Days_to_date[1]; 104c99: b9 9a 2d 12 00 mov $0x122d9a,%ecx 104c9e: c1 c8 02 ror $0x2,%eax return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0); 104ca1: 3d 28 5c 8f 02 cmp $0x28f5c28,%eax 104ca6: 0f 86 c4 00 00 00 jbe 104d70 days_to_date += 2; 104cac: 83 c1 04 add $0x4,%ecx uint32_t month = 0; 104caf: 31 c0 xor %eax,%eax 104cb1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 104cb8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 104cbf: 90 nop if (*day < *days_to_date) 104cc0: 0f b7 31 movzwl (%ecx),%esi ++month; 104cc3: 40 inc %eax if (*day < *days_to_date) 104cc4: 39 d6 cmp %edx,%esi 104cc6: 0f 87 e4 00 00 00 ja 104db0 ++days_to_date; 104ccc: 83 c1 02 add $0x2,%ecx while (month < 11) { 104ccf: 83 f8 0b cmp $0xb,%eax 104cd2: 75 ec jne 104cc0 104cd4: b8 0c 00 00 00 mov $0xc,%eax time_buffer->month = _Year_day_as_month( year, &year_days ) + 1; 104cd9: 89 43 04 mov %eax,0x4(%ebx) time_buffer->day = year_days + 1; time_buffer->hour = day_secs / RTEMS_SECS_PER_HOUR; 104cdc: 8b 45 d0 mov -0x30(%ebp),%eax time_buffer->day = year_days + 1; 104cdf: 42 inc %edx 104ce0: 29 f2 sub %esi,%edx 104ce2: 89 53 08 mov %edx,0x8(%ebx) time_buffer->hour = day_secs / RTEMS_SECS_PER_HOUR; 104ce5: ba c5 b3 a2 91 mov $0x91a2b3c5,%edx 104cea: f7 e2 mul %edx time_buffer->minute = day_secs % RTEMS_SECS_PER_HOUR; 104cec: 8b 45 d0 mov -0x30(%ebp),%eax time_buffer->hour = day_secs / RTEMS_SECS_PER_HOUR; 104cef: c1 ea 0b shr $0xb,%edx 104cf2: 89 53 0c mov %edx,0xc(%ebx) time_buffer->minute = day_secs % RTEMS_SECS_PER_HOUR; 104cf5: 69 d2 10 0e 00 00 imul $0xe10,%edx,%edx 104cfb: 29 d0 sub %edx,%eax time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE; 104cfd: ba 89 88 88 88 mov $0x88888889,%edx time_buffer->minute = day_secs % RTEMS_SECS_PER_HOUR; 104d02: 89 c1 mov %eax,%ecx time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE; 104d04: f7 e2 mul %edx time_buffer->minute = time_buffer->minute / RTEMS_SECS_PER_MINUTE; time_buffer->ticks = now.tv_usec / 104d06: 8b 45 e4 mov -0x1c(%ebp),%eax time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE; 104d09: c1 ea 05 shr $0x5,%edx time_buffer->minute = time_buffer->minute / RTEMS_SECS_PER_MINUTE; 104d0c: 89 53 10 mov %edx,0x10(%ebx) time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE; 104d0f: 89 d6 mov %edx,%esi 104d11: c1 e6 04 shl $0x4,%esi 104d14: 29 d6 sub %edx,%esi time_buffer->ticks = now.tv_usec / 104d16: 31 d2 xor %edx,%edx 104d18: f7 35 78 25 12 00 divl 0x122578 time_buffer->second = time_buffer->minute % RTEMS_SECS_PER_MINUTE; 104d1e: c1 e6 02 shl $0x2,%esi 104d21: 29 f1 sub %esi,%ecx 104d23: 89 4b 14 mov %ecx,0x14(%ebx) time_buffer->ticks = now.tv_usec / 104d26: 89 43 18 mov %eax,0x18(%ebx) rtems_configuration_get_microseconds_per_tick( ); return RTEMS_SUCCESSFUL; } 104d29: 83 c4 4c add $0x4c,%esp return RTEMS_SUCCESSFUL; 104d2c: 31 c0 xor %eax,%eax } 104d2e: 5b pop %ebx 104d2f: 5e pop %esi 104d30: 5f pop %edi 104d31: 5d pop %ebp 104d32: c3 ret 104d33: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 104d3a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0); 104d40: 69 ce 29 5c 8f c2 imul $0xc28f5c29,%esi,%ecx 104d46: 89 f0 mov %esi,%eax 104d48: 83 e0 03 and $0x3,%eax 104d4b: 75 73 jne 104dc0 104d4d: 89 cf mov %ecx,%edi 104d4f: c1 cf 02 ror $0x2,%edi 104d52: 81 ff 28 5c 8f 02 cmp $0x28f5c28,%edi 104d58: 77 71 ja 104dcb 104d5a: c1 c9 04 ror $0x4,%ecx 104d5d: 81 f9 0a d7 a3 00 cmp $0xa3d70a,%ecx 104d63: 76 66 jbe 104dcb time_buffer->year = year; 104d65: 89 33 mov %esi,(%ebx) return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0); 104d67: e9 27 ff ff ff jmp 104c93 104d6c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 104d70: 69 f6 29 5c 8f c2 imul $0xc28f5c29,%esi,%esi days_to_date = _TOD_Days_to_date[1]; 104d76: b9 9a 2d 12 00 mov $0x122d9a,%ecx 104d7b: c1 ce 04 ror $0x4,%esi return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0); 104d7e: 81 fe 0a d7 a3 00 cmp $0xa3d70a,%esi 104d84: 0f 86 22 ff ff ff jbe 104cac days_to_date = _TOD_Days_to_date[0]; 104d8a: b9 80 2d 12 00 mov $0x122d80,%ecx 104d8f: e9 18 ff ff ff jmp 104cac 104d94: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 104d9b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 104d9f: 90 nop } 104da0: 83 c4 4c add $0x4c,%esp return RTEMS_NOT_DEFINED; 104da3: b8 0b 00 00 00 mov $0xb,%eax } 104da8: 5b pop %ebx 104da9: 5e pop %esi 104daa: 5f pop %edi 104dab: 5d pop %ebp 104dac: c3 ret 104dad: 8d 76 00 lea 0x0(%esi),%esi *day -= *(days_to_date - 1); 104db0: 0f b7 71 fe movzwl -0x2(%ecx),%esi 104db4: e9 20 ff ff ff jmp 104cd9 104db9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi time_buffer->year = year; 104dc0: c1 c9 04 ror $0x4,%ecx return (((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0); 104dc3: 81 f9 0a d7 a3 00 cmp $0xa3d70a,%ecx 104dc9: 77 15 ja 104de0 <== ALWAYS TAKEN year_days += 1; 104dcb: 42 inc %edx 104dcc: e9 b8 fe ff ff jmp 104c89 104dd1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 104dd8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 104ddf: 90 nop time_buffer->year = year; 104de0: 89 33 mov %esi,(%ebx) days_to_date = _TOD_Days_to_date[0]; 104de2: b9 80 2d 12 00 mov $0x122d80,%ecx 104de7: e9 c0 fe ff ff jmp 104cac 104dec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi } 104df0: 83 c4 4c add $0x4c,%esp return RTEMS_INVALID_ADDRESS; 104df3: b8 09 00 00 00 mov $0x9,%eax } 104df8: 5b pop %ebx 104df9: 5e pop %esi 104dfa: 5f pop %edi 104dfb: 5d pop %ebp 104dfc: c3 ret 104dfd: 90 nop 104dfe: 90 nop 104dff: 90 nop =============================================================================== 00104fb0 : #include #include #include rtems_status_code rtems_clock_tick( void ) { 104fb0: 55 push %ebp 104fb1: 89 e5 mov %esp,%ebp 104fb3: 83 ec 28 sub $0x28,%esp ISR_lock_Context lock_context; _Timecounter_Acquire( &lock_context ); 104fb6: 9c pushf 104fb7: fa cli 104fb8: 58 pop %eax 104fb9: 89 45 f4 mov %eax,-0xc(%ebp) _Timecounter_Tick_simple( 104fbc: 8d 45 f4 lea -0xc(%ebp),%eax 104fbf: 89 44 24 08 mov %eax,0x8(%esp) 104fc3: 31 c0 xor %eax,%eax 104fc5: 89 44 24 04 mov %eax,0x4(%esp) 104fc9: a1 d4 1f 12 00 mov 0x121fd4,%eax 104fce: 89 04 24 mov %eax,(%esp) 104fd1: e8 1a 25 00 00 call 1074f0 <_Timecounter_Tick_simple> enabled = _Thread_Dispatch_disable_level == 0; 104fd6: a1 70 af 12 00 mov 0x12af70,%eax rtems_configuration_get_microseconds_per_tick(), 0, &lock_context ); if ( _Thread_Dispatch_is_enabled() ) { 104fdb: 85 c0 test %eax,%eax 104fdd: 74 11 je 104ff0 <== ALWAYS TAKEN _Thread_Dispatch(); } return RTEMS_SUCCESSFUL; } 104fdf: 89 ec mov %ebp,%esp <== NOT EXECUTED 104fe1: 31 c0 xor %eax,%eax <== NOT EXECUTED 104fe3: 5d pop %ebp <== NOT EXECUTED 104fe4: c3 ret <== NOT EXECUTED 104fe5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 104fec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED _Thread_Dispatch(); 104ff0: e8 fb 32 00 00 call 1082f0 <_Thread_Dispatch> } 104ff5: 89 ec mov %ebp,%esp 104ff7: 31 c0 xor %eax,%eax 104ff9: 5d pop %ebp 104ffa: c3 ret 104ffb: 90 nop 104ffc: 90 nop 104ffd: 90 nop 104ffe: 90 nop 104fff: 90 nop =============================================================================== 00105550 : rtems_status_code rtems_object_get_class_information( int the_api, int the_class, rtems_object_api_class_information *info ) { 105550: 55 push %ebp 105551: 89 e5 mov %esp,%ebp 105553: 83 ec 18 sub $0x18,%esp 105556: 89 5d fc mov %ebx,-0x4(%ebp) 105559: 8b 5d 10 mov 0x10(%ebp),%ebx int i; /* * Validate parameters and look up information structure. */ if ( !info ) 10555c: 85 db test %ebx,%ebx 10555e: 74 70 je 1055d0 return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); 105560: 0f b7 45 0c movzwl 0xc(%ebp),%eax 105564: 89 44 24 04 mov %eax,0x4(%esp) 105568: 8b 45 08 mov 0x8(%ebp),%eax 10556b: 89 04 24 mov %eax,(%esp) 10556e: e8 5d 1f 00 00 call 1074d0 <_Objects_Get_information> if ( !obj_info ) 105573: 85 c0 test %eax,%eax 105575: 74 69 je 1055e0 return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = _Objects_Get_minimum_id( obj_info->maximum_id ); 105577: 8b 10 mov (%eax),%edx info->maximum_id = obj_info->maximum_id; 105579: 89 53 04 mov %edx,0x4(%ebx) * * @return The corresponding ID with the minimum index. */ RTEMS_INLINE_ROUTINE Objects_Id _Objects_Get_minimum_id( Objects_Id id ) { id &= ~OBJECTS_INDEX_MASK; 10557c: 89 d1 mov %edx,%ecx 10557e: 0f b7 d2 movzwl %dx,%edx 105581: 81 e1 00 00 ff ff and $0xffff0000,%ecx id += (Objects_Id) OBJECTS_INDEX_MINIMUM << OBJECTS_INDEX_START_BIT; 105587: 41 inc %ecx */ RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Is_auto_extend( const Objects_Information *information ) { return information->objects_per_block != 0; 105588: 66 83 78 12 00 cmpw $0x0,0x12(%eax) id += (Objects_Id) OBJECTS_INDEX_MINIMUM << OBJECTS_INDEX_START_BIT; 10558d: 89 0b mov %ecx,(%ebx) info->auto_extend = _Objects_Is_auto_extend( obj_info ); info->maximum = _Objects_Get_maximum_index( obj_info ); 10558f: 89 53 08 mov %edx,0x8(%ebx) info->auto_extend = _Objects_Is_auto_extend( obj_info ); 105592: 0f 95 43 0c setne 0xc(%ebx) for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 105596: 85 d2 test %edx,%edx 105598: 74 23 je 1055bd <== NEVER TAKEN if ( !obj_info->local_table[i] ) 10559a: 8b 48 04 mov 0x4(%eax),%ecx 10559d: 8d 41 04 lea 0x4(%ecx),%eax 1055a0: 8d 4c 91 04 lea 0x4(%ecx,%edx,4),%ecx for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 1055a4: 31 d2 xor %edx,%edx 1055a6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1055ad: 8d 76 00 lea 0x0(%esi),%esi unallocated++; 1055b0: 83 38 01 cmpl $0x1,(%eax) 1055b3: 83 d2 00 adc $0x0,%edx for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 1055b6: 83 c0 04 add $0x4,%eax 1055b9: 39 c8 cmp %ecx,%eax 1055bb: 75 f3 jne 1055b0 info->unallocated = unallocated; 1055bd: 89 53 10 mov %edx,0x10(%ebx) return RTEMS_SUCCESSFUL; 1055c0: 31 c0 xor %eax,%eax } 1055c2: 8b 5d fc mov -0x4(%ebp),%ebx 1055c5: 89 ec mov %ebp,%esp 1055c7: 5d pop %ebp 1055c8: c3 ret 1055c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1055d0: 8b 5d fc mov -0x4(%ebp),%ebx 1055d3: 89 ec mov %ebp,%esp return RTEMS_INVALID_ADDRESS; 1055d5: b8 09 00 00 00 mov $0x9,%eax } 1055da: 5d pop %ebp 1055db: c3 ret 1055dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi return RTEMS_INVALID_NUMBER; 1055e0: b8 0a 00 00 00 mov $0xa,%eax 1055e5: eb db jmp 1055c2 1055e7: 90 nop 1055e8: 90 nop 1055e9: 90 nop 1055ea: 90 nop 1055eb: 90 nop 1055ec: 90 nop 1055ed: 90 nop 1055ee: 90 nop 1055ef: 90 nop =============================================================================== 00103db0 : */ rtems_status_code rtems_object_set_name( rtems_id id, const char *name ) { 103db0: 55 push %ebp 103db1: 89 e5 mov %esp,%ebp 103db3: 83 ec 28 sub $0x28,%esp 103db6: 89 7d fc mov %edi,-0x4(%ebp) 103db9: 8b 7d 0c mov 0xc(%ebp),%edi 103dbc: 89 75 f8 mov %esi,-0x8(%ebp) 103dbf: 8b 75 08 mov 0x8(%ebp),%esi 103dc2: 89 5d f4 mov %ebx,-0xc(%ebp) Objects_Information *information; Objects_Control *the_object; Objects_Id tmpId; Status_Control status; if ( !name ) 103dc5: 85 ff test %edi,%edi 103dc7: 0f 84 83 00 00 00 je 103e50 return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? rtems_task_self() : id; 103dcd: 85 f6 test %esi,%esi 103dcf: 74 4f je 103e20 information = _Objects_Get_information_id( tmpId ); 103dd1: 89 34 24 mov %esi,(%esp) 103dd4: e8 27 17 00 00 call 105500 <_Objects_Get_information_id> if ( !information ) 103dd9: 85 c0 test %eax,%eax information = _Objects_Get_information_id( tmpId ); 103ddb: 89 c3 mov %eax,%ebx if ( !information ) 103ddd: 74 56 je 103e35 * * @see _Objects_Allocator_unlock() and _Objects_Allocate(). */ RTEMS_INLINE_ROUTINE void _Objects_Allocator_lock( void ) { _RTEMS_Lock_allocator(); 103ddf: e8 fc 01 00 00 call 103fe0 <_RTEMS_Lock_allocator> return RTEMS_INVALID_ID; _Objects_Allocator_lock(); the_object = _Objects_Get_no_protection( tmpId, information ); 103de4: 89 5c 24 04 mov %ebx,0x4(%esp) 103de8: 89 34 24 mov %esi,(%esp) 103deb: e8 80 18 00 00 call 105670 <_Objects_Get_no_protection> if ( the_object == NULL ) { 103df0: 85 c0 test %eax,%eax 103df2: 74 7c je 103e70 _Objects_Allocator_unlock(); return RTEMS_INVALID_ID; } status = _Objects_Set_name( information, the_object, name ); 103df4: 89 1c 24 mov %ebx,(%esp) 103df7: 89 7c 24 08 mov %edi,0x8(%esp) 103dfb: 89 44 24 04 mov %eax,0x4(%esp) 103dff: e8 bc 18 00 00 call 1056c0 <_Objects_Set_name> 103e04: 89 c3 mov %eax,%ebx * previous thread life protection state and thus may not return if the * executing thread was restarted or deleted in the mean-time. */ RTEMS_INLINE_ROUTINE void _Objects_Allocator_unlock( void ) { _RTEMS_Unlock_allocator(); 103e06: e8 f5 01 00 00 call 104000 <_RTEMS_Unlock_allocator> _Objects_Allocator_unlock(); return STATUS_GET_CLASSIC( status ); 103e0b: 0f b6 c3 movzbl %bl,%eax } 103e0e: 8b 5d f4 mov -0xc(%ebp),%ebx 103e11: 8b 75 f8 mov -0x8(%ebp),%esi 103e14: 8b 7d fc mov -0x4(%ebp),%edi 103e17: 89 ec mov %ebp,%esp 103e19: 5d pop %ebp 103e1a: c3 ret 103e1b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 103e1f: 90 nop tmpId = (id == OBJECTS_ID_OF_SELF) ? rtems_task_self() : id; 103e20: e8 db 00 00 00 call 103f00 103e25: 89 c6 mov %eax,%esi information = _Objects_Get_information_id( tmpId ); 103e27: 89 34 24 mov %esi,(%esp) 103e2a: e8 d1 16 00 00 call 105500 <_Objects_Get_information_id> if ( !information ) 103e2f: 85 c0 test %eax,%eax information = _Objects_Get_information_id( tmpId ); 103e31: 89 c3 mov %eax,%ebx if ( !information ) 103e33: 75 aa jne 103ddf <== ALWAYS TAKEN } 103e35: 8b 5d f4 mov -0xc(%ebp),%ebx return RTEMS_INVALID_ID; 103e38: b8 04 00 00 00 mov $0x4,%eax } 103e3d: 8b 75 f8 mov -0x8(%ebp),%esi 103e40: 8b 7d fc mov -0x4(%ebp),%edi 103e43: 89 ec mov %ebp,%esp 103e45: 5d pop %ebp 103e46: c3 ret 103e47: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 103e4e: 66 90 xchg %ax,%ax 103e50: 8b 5d f4 mov -0xc(%ebp),%ebx return RTEMS_INVALID_ADDRESS; 103e53: b8 09 00 00 00 mov $0x9,%eax } 103e58: 8b 75 f8 mov -0x8(%ebp),%esi 103e5b: 8b 7d fc mov -0x4(%ebp),%edi 103e5e: 89 ec mov %ebp,%esp 103e60: 5d pop %ebp 103e61: c3 ret 103e62: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 103e69: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 103e70: e8 8b 01 00 00 call 104000 <_RTEMS_Unlock_allocator> return RTEMS_INVALID_ID; 103e75: b8 04 00 00 00 mov $0x4,%eax 103e7a: eb 92 jmp 103e0e 103e7c: 90 nop 103e7d: 90 nop 103e7e: 90 nop 103e7f: 90 nop =============================================================================== 001143c0 : { 1143c0: 55 push %ebp 1143c1: 89 e5 mov %esp,%ebp 1143c3: 83 ec 28 sub $0x28,%esp 1143c6: 89 75 f8 mov %esi,-0x8(%ebp) if ( !rtems_is_name_valid( name ) ) { 1143c9: 8b 75 08 mov 0x8(%ebp),%esi { 1143cc: 89 5d f4 mov %ebx,-0xc(%ebp) 1143cf: 8b 5d 14 mov 0x14(%ebp),%ebx 1143d2: 89 7d fc mov %edi,-0x4(%ebp) if ( !rtems_is_name_valid( name ) ) { 1143d5: 85 f6 test %esi,%esi 1143d7: 0f 84 f3 00 00 00 je 1144d0 if ( starting_address == NULL ) { 1143dd: 8b 4d 1c mov 0x1c(%ebp),%ecx 1143e0: 85 c9 test %ecx,%ecx 1143e2: 0f 84 c8 00 00 00 je 1144b0 <== NEVER TAKEN 1143e8: 8b 55 0c mov 0xc(%ebp),%edx 1143eb: 85 d2 test %edx,%edx 1143ed: 0f 84 bd 00 00 00 je 1144b0 if ( length == 0 ) 1143f3: 8b 45 10 mov 0x10(%ebp),%eax return RTEMS_INVALID_SIZE; 1143f6: bf 08 00 00 00 mov $0x8,%edi if ( length == 0 ) 1143fb: 85 c0 test %eax,%eax 1143fd: 0f 94 c2 sete %dl if ( buffer_size == 0 ) 114400: 83 fb 07 cmp $0x7,%ebx 114403: 0f 96 c0 setbe %al if ( length < buffer_size ) 114406: 08 c2 or %al,%dl 114408: 0f 85 8d 00 00 00 jne 11449b 11440e: 39 5d 10 cmp %ebx,0x10(%ebp) 114411: 0f 82 84 00 00 00 jb 11449b if ( buffer_size < sizeof( Chain_Node ) ) 114417: f6 c3 03 test $0x3,%bl 11441a: 75 7f jne 11449b <== NEVER TAKEN if ( (uintptr_t) starting_address % CPU_SIZEOF_POINTER != 0 ) { 11441c: 8b 7d 0c mov 0xc(%ebp),%edi 11441f: 83 e7 03 and $0x3,%edi 114422: 0f 85 88 00 00 00 jne 1144b0 return (Partition_Control *) _Objects_Allocate( &_Partition_Information ); 114428: c7 04 24 80 52 15 00 movl $0x155280,(%esp) 11442f: e8 ec 2b 00 00 call 117020 <_Objects_Allocate> if ( !the_partition ) { 114434: 85 c0 test %eax,%eax return (Partition_Control *) _Objects_Allocate( &_Partition_Information ); 114436: 89 c6 mov %eax,%esi if ( !the_partition ) { 114438: 0f 84 b2 00 00 00 je 1144f0 the_partition->buffer_size = buffer_size; 11443e: 89 5e 18 mov %ebx,0x18(%esi) the_partition->starting_address = starting_address; 114441: 8b 45 0c mov 0xc(%ebp),%eax _Chain_Initialize( 114444: 31 d2 xor %edx,%edx the_partition->number_of_used_blocks = 0; 114446: c7 46 20 00 00 00 00 movl $0x0,0x20(%esi) the_partition->starting_address = starting_address; 11444d: 89 46 10 mov %eax,0x10(%esi) the_partition->length = length; 114450: 8b 45 10 mov 0x10(%ebp),%eax 114453: 89 46 14 mov %eax,0x14(%esi) the_partition->attribute_set = attribute_set; 114456: 8b 45 18 mov 0x18(%ebp),%eax 114459: 89 46 1c mov %eax,0x1c(%esi) _Chain_Initialize( 11445c: 8b 45 10 mov 0x10(%ebp),%eax 11445f: 89 5c 24 0c mov %ebx,0xc(%esp) 114463: f7 f3 div %ebx 114465: 89 44 24 08 mov %eax,0x8(%esp) 114469: 8b 45 0c mov 0xc(%ebp),%eax 11446c: 89 44 24 04 mov %eax,0x4(%esp) 114470: 8d 46 24 lea 0x24(%esi),%eax 114473: 89 04 24 mov %eax,(%esp) 114476: e8 b5 0f 00 00 call 115430 <_Chain_Initialize> the_object->name = name; 11447b: 8b 45 08 mov 0x8(%ebp),%eax information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object; 11447e: 8b 15 84 52 15 00 mov 0x155284,%edx *id = the_partition->Object.id; 114484: 8b 4d 1c mov 0x1c(%ebp),%ecx the_object->name = name; 114487: 89 46 0c mov %eax,0xc(%esi) _Objects_Get_index( the_object->id ), 11448a: 8b 46 08 mov 0x8(%esi),%eax information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object; 11448d: 0f b7 d8 movzwl %ax,%ebx 114490: 89 74 9a fc mov %esi,-0x4(%edx,%ebx,4) 114494: 89 01 mov %eax,(%ecx) _RTEMS_Unlock_allocator(); 114496: e8 e5 0e 00 00 call 115380 <_RTEMS_Unlock_allocator> } 11449b: 8b 5d f4 mov -0xc(%ebp),%ebx 11449e: 89 f8 mov %edi,%eax 1144a0: 8b 75 f8 mov -0x8(%ebp),%esi 1144a3: 8b 7d fc mov -0x4(%ebp),%edi 1144a6: 89 ec mov %ebp,%esp 1144a8: 5d pop %ebp 1144a9: c3 ret 1144aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi return RTEMS_INVALID_ADDRESS; 1144b0: bf 09 00 00 00 mov $0x9,%edi } 1144b5: 8b 5d f4 mov -0xc(%ebp),%ebx 1144b8: 8b 75 f8 mov -0x8(%ebp),%esi 1144bb: 89 f8 mov %edi,%eax 1144bd: 8b 7d fc mov -0x4(%ebp),%edi 1144c0: 89 ec mov %ebp,%esp 1144c2: 5d pop %ebp 1144c3: c3 ret 1144c4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1144cb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 1144cf: 90 nop return RTEMS_INVALID_NAME; 1144d0: bf 03 00 00 00 mov $0x3,%edi } 1144d5: 8b 5d f4 mov -0xc(%ebp),%ebx 1144d8: 8b 75 f8 mov -0x8(%ebp),%esi 1144db: 89 f8 mov %edi,%eax 1144dd: 8b 7d fc mov -0x4(%ebp),%edi 1144e0: 89 ec mov %ebp,%esp 1144e2: 5d pop %ebp 1144e3: c3 ret 1144e4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1144eb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 1144ef: 90 nop 1144f0: e8 8b 0e 00 00 call 115380 <_RTEMS_Unlock_allocator> return RTEMS_TOO_MANY; 1144f5: bf 05 00 00 00 mov $0x5,%edi 1144fa: eb 9f jmp 11449b 1144fc: 90 nop 1144fd: 90 nop 1144fe: 90 nop 1144ff: 90 nop =============================================================================== 00104710 : rtems_status_code rtems_partition_return_buffer( rtems_id id, void *buffer ) { 104710: 55 push %ebp return (Partition_Control *) _Objects_Get( 104711: b8 40 51 12 00 mov $0x125140,%eax 104716: 89 e5 mov %esp,%ebp 104718: 56 push %esi 104719: 53 push %ebx 10471a: 83 ec 20 sub $0x20,%esp 10471d: 89 44 24 08 mov %eax,0x8(%esp) 104721: 8d 45 f4 lea -0xc(%ebp),%eax 104724: 8b 5d 0c mov 0xc(%ebp),%ebx 104727: 89 44 24 04 mov %eax,0x4(%esp) 10472b: 8b 45 08 mov 0x8(%ebp),%eax 10472e: 89 04 24 mov %eax,(%esp) 104731: e8 2a 19 00 00 call 106060 <_Objects_Get> Partition_Control *the_partition; ISR_lock_Context lock_context; the_partition = _Partition_Get( id, &lock_context ); if ( the_partition == NULL ) { 104736: 85 c0 test %eax,%eax 104738: 74 56 je 104790 starting = the_partition->starting_address; 10473a: 8b 50 10 mov 0x10(%eax),%edx 10473d: 89 c1 mov %eax,%ecx RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( const void *base, uintptr_t offset ) { return (void *)((uintptr_t)base + offset); 10473f: 8b 40 14 mov 0x14(%eax),%eax 104742: 01 d0 add %edx,%eax && _Partition_Is_address_on_buffer_boundary( the_partition, the_buffer ); 104744: 39 c3 cmp %eax,%ebx 104746: 77 11 ja 104759 104748: 39 d3 cmp %edx,%ebx 10474a: 72 0d jb 104759 <== NEVER TAKEN RTEMS_INLINE_ROUTINE intptr_t _Addresses_Subtract( const void *left, const void *right ) { return (intptr_t) ( (const char *) left - (const char *) right ); 10474c: 89 d8 mov %ebx,%eax 10474e: 29 d0 sub %edx,%eax return ( offset % the_partition->buffer_size ) == 0; 104750: 31 d2 xor %edx,%edx 104752: f7 71 18 divl 0x18(%ecx) && _Partition_Is_address_on_buffer_boundary( the_partition, the_buffer ); 104755: 85 d2 test %edx,%edx 104757: 74 17 je 104770 _ISR_lock_Release_and_ISR_enable( &the_partition->Lock, lock_context ); 104759: ff 75 f4 push -0xc(%ebp) 10475c: 9d popf _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; _Partition_Release( the_partition, &lock_context ); return RTEMS_SUCCESSFUL; } 10475d: 83 c4 20 add $0x20,%esp return RTEMS_INVALID_ADDRESS; 104760: ba 09 00 00 00 mov $0x9,%edx } 104765: 5b pop %ebx 104766: 89 d0 mov %edx,%eax 104768: 5e pop %esi 104769: 5d pop %ebp 10476a: c3 ret 10476b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10476f: 90 nop old_last = tail->previous; 104770: 8b 41 2c mov 0x2c(%ecx),%eax return &the_chain->Tail.Node; 104773: 8d 71 28 lea 0x28(%ecx),%esi 104776: 89 33 mov %esi,(%ebx) tail->previous = the_node; 104778: 89 59 2c mov %ebx,0x2c(%ecx) old_last->next = the_node; 10477b: 89 18 mov %ebx,(%eax) the_node->previous = old_last; 10477d: 89 43 04 mov %eax,0x4(%ebx) the_partition->number_of_used_blocks -= 1; 104780: ff 49 20 decl 0x20(%ecx) 104783: ff 75 f4 push -0xc(%ebp) 104786: 9d popf } 104787: 83 c4 20 add $0x20,%esp 10478a: 89 d0 mov %edx,%eax 10478c: 5b pop %ebx 10478d: 5e pop %esi 10478e: 5d pop %ebp 10478f: c3 ret 104790: 83 c4 20 add $0x20,%esp return RTEMS_INVALID_ID; 104793: ba 04 00 00 00 mov $0x4,%edx } 104798: 5b pop %ebx 104799: 89 d0 mov %edx,%eax 10479b: 5e pop %esi 10479c: 5d pop %ebp 10479d: c3 ret 10479e: 90 nop 10479f: 90 nop =============================================================================== 00104780 : { 104780: 55 push %ebp 104781: 89 e5 mov %esp,%ebp 104783: 83 ec 28 sub $0x28,%esp 104786: 89 75 f8 mov %esi,-0x8(%ebp) if ( !rtems_is_name_valid( name ) ) 104789: 8b 75 08 mov 0x8(%ebp),%esi { 10478c: 89 5d f4 mov %ebx,-0xc(%ebp) 10478f: 89 7d fc mov %edi,-0x4(%ebp) if ( !rtems_is_name_valid( name ) ) 104792: 85 f6 test %esi,%esi 104794: 0f 84 f6 00 00 00 je 104890 if ( !id ) 10479a: 8b 5d 0c mov 0xc(%ebp),%ebx 10479d: 85 db test %ebx,%ebx 10479f: 0f 84 5b 01 00 00 je 104900 * the inactive chain of free period control blocks. */ RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void ) { return (Rate_monotonic_Control *) _Objects_Allocate( &_Rate_monotonic_Information ); 1047a5: c7 04 24 c0 7c 12 00 movl $0x127cc0,(%esp) 1047ac: e8 af 25 00 00 call 106d60 <_Objects_Allocate> if ( !the_period ) { 1047b1: 85 c0 test %eax,%eax 1047b3: 0f 84 67 01 00 00 je 104920 the_period->owner = _Thread_Get_executing(); 1047b9: 8b 15 d8 d0 12 00 mov 0x12d0d8,%edx ) { Rate_monotonic_Statistics *statistics; statistics = &the_period->Statistics; memset( statistics, 0, sizeof( *statistics ) ); 1047bf: 31 db xor %ebx,%ebx 1047c1: a8 01 test $0x1,%al RTEMS_INLINE_ROUTINE void _Priority_Node_initialize( Priority_Node *node, Priority_Control priority ) { node->priority = priority; 1047c3: c7 40 40 00 00 00 00 movl $0x0,0x40(%eax) 1047ca: 8d 48 60 lea 0x60(%eax),%ecx 1047cd: be 38 00 00 00 mov $0x38,%esi 1047d2: c7 40 44 00 00 00 00 movl $0x0,0x44(%eax) * * @see _RBTree_Is_node_off_tree(). */ RTEMS_INLINE_ROUTINE void _RBTree_Set_off_tree( RBTree_Node *the_node ) { RB_COLOR( the_node, Node ) = -1; 1047d9: c7 40 3c ff ff ff ff movl $0xffffffff,0x3c(%eax) 1047e0: 89 50 4c mov %edx,0x4c(%eax) the_period->state = RATE_MONOTONIC_INACTIVE; 1047e3: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) RTEMS_INLINE_ROUTINE void _Watchdog_Set_state( Watchdog_Control *the_watchdog, Watchdog_State state ) { RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state; 1047ea: c7 40 1c 02 00 00 00 movl $0x2,0x1c(%eax) Watchdog_Control *the_watchdog, Watchdog_Service_routine_entry routine ) { _Assert( _Watchdog_Get_state( the_watchdog ) == WATCHDOG_INACTIVE ); the_watchdog->routine = routine; 1047f1: c7 40 20 20 52 10 00 movl $0x105220,0x20(%eax) 1047f8: 0f 85 32 01 00 00 jne 104930 <== NEVER TAKEN 1047fe: f6 c1 02 test $0x2,%cl 104801: 0f 85 49 01 00 00 jne 104950 <== NEVER TAKEN 104807: 89 f7 mov %esi,%edi 104809: 31 d2 xor %edx,%edx 10480b: 83 e7 f8 and $0xfffffff8,%edi 10480e: 89 1c 11 mov %ebx,(%ecx,%edx,1) 104811: 89 5c 11 04 mov %ebx,0x4(%ecx,%edx,1) 104815: 83 c2 08 add $0x8,%edx 104818: 39 fa cmp %edi,%edx 10481a: 72 f2 jb 10480e 10481c: 01 d1 add %edx,%ecx 10481e: f7 c6 04 00 00 00 test $0x4,%esi 104824: 0f 85 b6 00 00 00 jne 1048e0 <== NEVER TAKEN 10482a: f7 c6 02 00 00 00 test $0x2,%esi 104830: 0f 85 8a 00 00 00 jne 1048c0 <== NEVER TAKEN 104836: 83 e6 01 and $0x1,%esi 104839: 75 75 jne 1048b0 <== NEVER TAKEN struct timespec _ts; _ts.tv_sec = _seconds; _ts.tv_nsec = _nanoseconds; *_time = tstosbt(_ts); 10483b: ba 01 7d c1 25 mov $0x25c17d01,%edx ) { _Assert( information != NULL ); _Assert( the_object != NULL ); the_object->name = name; 104840: 8b 5d 08 mov 0x8(%ebp),%ebx 104843: b9 ff ff ff 7f mov $0x7fffffff,%ecx 104848: 89 90 80 00 00 00 mov %edx,0x80(%eax) _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10484e: 8b 50 08 mov 0x8(%eax),%edx 104851: 89 88 84 00 00 00 mov %ecx,0x84(%eax) information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object; 104857: 8b 0d c4 7c 12 00 mov 0x127cc4,%ecx 10485d: c7 40 68 01 7d c1 25 movl $0x25c17d01,0x68(%eax) the_object->name = name; 104864: 89 58 0c mov %ebx,0xc(%eax) 104867: c7 40 6c ff ff ff 7f movl $0x7fffffff,0x6c(%eax) information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object; 10486e: 0f b7 da movzwl %dx,%ebx 104871: 89 44 99 fc mov %eax,-0x4(%ecx,%ebx,4) *id = the_period->Object.id; 104875: 8b 45 0c mov 0xc(%ebp),%eax 104878: 89 10 mov %edx,(%eax) * previous thread life protection state and thus may not return if the * executing thread was restarted or deleted in the mean-time. */ RTEMS_INLINE_ROUTINE void _Objects_Allocator_unlock( void ) { _RTEMS_Unlock_allocator(); 10487a: e8 61 10 00 00 call 1058e0 <_RTEMS_Unlock_allocator> return RTEMS_SUCCESSFUL; 10487f: 31 c0 xor %eax,%eax } 104881: 8b 5d f4 mov -0xc(%ebp),%ebx 104884: 8b 75 f8 mov -0x8(%ebp),%esi 104887: 8b 7d fc mov -0x4(%ebp),%edi 10488a: 89 ec mov %ebp,%esp 10488c: 5d pop %ebp 10488d: c3 ret 10488e: 66 90 xchg %ax,%ax 104890: 8b 5d f4 mov -0xc(%ebp),%ebx return RTEMS_INVALID_NAME; 104893: b8 03 00 00 00 mov $0x3,%eax } 104898: 8b 75 f8 mov -0x8(%ebp),%esi 10489b: 8b 7d fc mov -0x4(%ebp),%edi 10489e: 89 ec mov %ebp,%esp 1048a0: 5d pop %ebp 1048a1: c3 ret 1048a2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1048a9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1048b0: c6 01 00 movb $0x0,(%ecx) <== NOT EXECUTED 1048b3: eb 86 jmp 10483b <== NOT EXECUTED 1048b5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 1048bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 1048c0: 66 c7 01 00 00 movw $0x0,(%ecx) <== NOT EXECUTED 1048c5: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED 1048c8: 83 e6 01 and $0x1,%esi <== NOT EXECUTED 1048cb: 0f 84 6a ff ff ff je 10483b <== NOT EXECUTED 1048d1: eb dd jmp 1048b0 <== NOT EXECUTED 1048d3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 1048da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED 1048e0: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED 1048e6: 83 c1 04 add $0x4,%ecx <== NOT EXECUTED 1048e9: f7 c6 02 00 00 00 test $0x2,%esi <== NOT EXECUTED 1048ef: 0f 84 41 ff ff ff je 104836 <== NOT EXECUTED 1048f5: eb c9 jmp 1048c0 <== NOT EXECUTED 1048f7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 1048fe: 66 90 xchg %ax,%ax <== NOT EXECUTED 104900: 8b 5d f4 mov -0xc(%ebp),%ebx return RTEMS_INVALID_ADDRESS; 104903: b8 09 00 00 00 mov $0x9,%eax } 104908: 8b 75 f8 mov -0x8(%ebp),%esi 10490b: 8b 7d fc mov -0x4(%ebp),%edi 10490e: 89 ec mov %ebp,%esp 104910: 5d pop %ebp 104911: c3 ret 104912: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 104919: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 104920: e8 bb 0f 00 00 call 1058e0 <_RTEMS_Unlock_allocator> return RTEMS_TOO_MANY; 104925: b8 05 00 00 00 mov $0x5,%eax 10492a: e9 52 ff ff ff jmp 104881 10492f: 90 nop 104930: c6 40 60 00 movb $0x0,0x60(%eax) <== NOT EXECUTED 104934: 8d 48 61 lea 0x61(%eax),%ecx <== NOT EXECUTED 104937: be 37 00 00 00 mov $0x37,%esi <== NOT EXECUTED 10493c: e9 bd fe ff ff jmp 1047fe <== NOT EXECUTED 104941: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 104948: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10494f: 90 nop <== NOT EXECUTED 104950: 66 c7 01 00 00 movw $0x0,(%ecx) <== NOT EXECUTED 104955: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED 104958: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED 10495b: e9 a7 fe ff ff jmp 104807 <== NOT EXECUTED =============================================================================== 00113670 : rtems_status_code rtems_rate_monotonic_get_statistics( rtems_id id, rtems_rate_monotonic_period_statistics *dst ) { 113670: 55 push %ebp 113671: 89 e5 mov %esp,%ebp 113673: 57 push %edi 113674: 56 push %esi 113675: 53 push %ebx 113676: 83 ec 2c sub $0x2c,%esp 113679: 8b 5d 0c mov 0xc(%ebp),%ebx Rate_monotonic_Control *the_period; ISR_lock_Context lock_context; const Rate_monotonic_Statistics *src; if ( dst == NULL ) { 11367c: 85 db test %ebx,%ebx 11367e: 0f 84 dc 00 00 00 je 113760 <== NEVER TAKEN Objects_Id id, ISR_lock_Context *lock_context ) { return (Rate_monotonic_Control *) _Objects_Get( id, lock_context, &_Rate_monotonic_Information ); 113684: b8 80 18 1a 00 mov $0x1a1880,%eax 113689: 89 44 24 08 mov %eax,0x8(%esp) 11368d: 8d 45 e4 lea -0x1c(%ebp),%eax 113690: 89 44 24 04 mov %eax,0x4(%esp) 113694: 8b 45 08 mov 0x8(%ebp),%eax 113697: 89 04 24 mov %eax,(%esp) 11369a: e8 b1 4d 00 00 call 118450 <_Objects_Get> return RTEMS_INVALID_ADDRESS; } the_period = _Rate_monotonic_Get( id, &lock_context ); if ( the_period == NULL ) { 11369f: 85 c0 test %eax,%eax 1136a1: 89 c1 mov %eax,%ecx 1136a3: 0f 84 c7 00 00 00 je 113770 } _Rate_monotonic_Acquire_critical( the_period, &lock_context ); src = &the_period->Statistics; dst->count = src->count; 1136a9: 8b 40 60 mov 0x60(%eax),%eax RTEMS_INLINE_ROUTINE void _Timestamp_To_timespec( const Timestamp_Control *_timestamp, struct timespec *_timespec ) { *_timespec = sbttots( *_timestamp ); 1136ac: 8b 51 6c mov 0x6c(%ecx),%edx 1136af: 89 03 mov %eax,(%ebx) dst->missed_count = src->missed_count; 1136b1: 8b 41 64 mov 0x64(%ecx),%eax _ts.tv_sec = _sbt >> 32; 1136b4: 89 d6 mov %edx,%esi 1136b6: c1 fe 1f sar $0x1f,%esi 1136b9: 89 43 04 mov %eax,0x4(%ebx) 1136bc: 8b 41 68 mov 0x68(%ecx),%eax 1136bf: 89 73 0c mov %esi,0xc(%ebx) return (ns + (1000000000 * (_sbt & 0xffffffffu) >> 32)); 1136c2: be 00 ca 9a 3b mov $0x3b9aca00,%esi 1136c7: 89 53 08 mov %edx,0x8(%ebx) 1136ca: f7 e6 mul %esi 1136cc: 8b 41 70 mov 0x70(%ecx),%eax _ts.tv_nsec = sbttons((uint32_t)_sbt); 1136cf: 89 53 10 mov %edx,0x10(%ebx) 1136d2: 8b 51 74 mov 0x74(%ecx),%edx 1136d5: 89 53 14 mov %edx,0x14(%ebx) _ts.tv_sec = _sbt >> 32; 1136d8: 89 d7 mov %edx,%edi return (ns + (1000000000 * (_sbt & 0xffffffffu) >> 32)); 1136da: f7 e6 mul %esi _ts.tv_sec = _sbt >> 32; 1136dc: c1 ff 1f sar $0x1f,%edi 1136df: 89 7b 18 mov %edi,0x18(%ebx) 1136e2: 8b 41 78 mov 0x78(%ecx),%eax _ts.tv_nsec = sbttons((uint32_t)_sbt); 1136e5: 89 53 1c mov %edx,0x1c(%ebx) 1136e8: 8b 51 7c mov 0x7c(%ecx),%edx 1136eb: 89 53 20 mov %edx,0x20(%ebx) _ts.tv_sec = _sbt >> 32; 1136ee: 89 d7 mov %edx,%edi return (ns + (1000000000 * (_sbt & 0xffffffffu) >> 32)); 1136f0: f7 e6 mul %esi _ts.tv_sec = _sbt >> 32; 1136f2: c1 ff 1f sar $0x1f,%edi 1136f5: 89 7b 24 mov %edi,0x24(%ebx) 1136f8: 8b 81 80 00 00 00 mov 0x80(%ecx),%eax _ts.tv_nsec = sbttons((uint32_t)_sbt); 1136fe: 89 53 28 mov %edx,0x28(%ebx) 113701: 8b 91 84 00 00 00 mov 0x84(%ecx),%edx 113707: 89 53 2c mov %edx,0x2c(%ebx) _ts.tv_sec = _sbt >> 32; 11370a: 89 d7 mov %edx,%edi return (ns + (1000000000 * (_sbt & 0xffffffffu) >> 32)); 11370c: f7 e6 mul %esi _ts.tv_sec = _sbt >> 32; 11370e: c1 ff 1f sar $0x1f,%edi 113711: 89 7b 30 mov %edi,0x30(%ebx) 113714: 8b 81 88 00 00 00 mov 0x88(%ecx),%eax _ts.tv_nsec = sbttons((uint32_t)_sbt); 11371a: 89 53 34 mov %edx,0x34(%ebx) 11371d: 8b 91 8c 00 00 00 mov 0x8c(%ecx),%edx 113723: 89 53 38 mov %edx,0x38(%ebx) _ts.tv_sec = _sbt >> 32; 113726: 89 d7 mov %edx,%edi return (ns + (1000000000 * (_sbt & 0xffffffffu) >> 32)); 113728: f7 e6 mul %esi _ts.tv_sec = _sbt >> 32; 11372a: c1 ff 1f sar $0x1f,%edi 11372d: 89 7b 3c mov %edi,0x3c(%ebx) 113730: 8b 81 90 00 00 00 mov 0x90(%ecx),%eax _ts.tv_nsec = sbttons((uint32_t)_sbt); 113736: 89 53 40 mov %edx,0x40(%ebx) 113739: 8b 91 94 00 00 00 mov 0x94(%ecx),%edx 11373f: 89 53 44 mov %edx,0x44(%ebx) _ts.tv_sec = _sbt >> 32; 113742: 89 d1 mov %edx,%ecx return (ns + (1000000000 * (_sbt & 0xffffffffu) >> 32)); 113744: f7 e6 mul %esi _ts.tv_sec = _sbt >> 32; 113746: c1 f9 1f sar $0x1f,%ecx 113749: 89 4b 48 mov %ecx,0x48(%ebx) _ts.tv_nsec = sbttons((uint32_t)_sbt); 11374c: 89 53 4c mov %edx,0x4c(%ebx) _ISR_lock_Release_and_ISR_enable( &the_period->Lock, lock_context ); 11374f: ff 75 e4 push -0x1c(%ebp) 113752: 9d popf _Timestamp_To_timespec( &src->min_wall_time, &dst->min_wall_time ); _Timestamp_To_timespec( &src->max_wall_time, &dst->max_wall_time ); _Timestamp_To_timespec( &src->total_wall_time, &dst->total_wall_time ); _Rate_monotonic_Release( the_period, &lock_context ); return RTEMS_SUCCESSFUL; 113753: 31 c0 xor %eax,%eax } 113755: 83 c4 2c add $0x2c,%esp 113758: 5b pop %ebx 113759: 5e pop %esi 11375a: 5f pop %edi 11375b: 5d pop %ebp 11375c: c3 ret 11375d: 8d 76 00 lea 0x0(%esi),%esi 113760: 83 c4 2c add $0x2c,%esp return RTEMS_INVALID_ADDRESS; 113763: b8 09 00 00 00 mov $0x9,%eax } 113768: 5b pop %ebx 113769: 5e pop %esi 11376a: 5f pop %edi 11376b: 5d pop %ebp 11376c: c3 ret 11376d: 8d 76 00 lea 0x0(%esi),%esi return RTEMS_INVALID_ID; 113770: b8 04 00 00 00 mov $0x4,%eax 113775: eb de jmp 113755 113777: 90 nop 113778: 90 nop 113779: 90 nop 11377a: 90 nop 11377b: 90 nop 11377c: 90 nop 11377d: 90 nop 11377e: 90 nop 11377f: 90 nop =============================================================================== 001138f0 : #define NANOSECONDS_FMT "%06ld" void rtems_rate_monotonic_report_statistics_with_plugin( const rtems_printer *printer ) { 1138f0: 55 push %ebp rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; rtems_printf( printer, "Period information by period\n" ); 1138f1: b8 e8 08 19 00 mov $0x1908e8,%eax { 1138f6: 89 e5 mov %esp,%ebp 1138f8: 57 push %edi 1138f9: 56 push %esi 1138fa: 53 push %ebx 1138fb: 81 ec dc 00 00 00 sub $0xdc,%esp rtems_printf( printer, "Period information by period\n" ); 113901: 89 44 24 04 mov %eax,0x4(%esp) { 113905: 8b 7d 08 mov 0x8(%ebp),%edi rtems_printf( printer, "Period information by period\n" ); 113908: 89 3c 24 mov %edi,(%esp) 11390b: e8 e0 fd fe ff call 1036f0 rtems_printf( printer, "--- CPU times are in seconds ---\n" ); 113910: b8 1c 09 19 00 mov $0x19091c,%eax 113915: 89 44 24 04 mov %eax,0x4(%esp) 113919: 89 3c 24 mov %edi,(%esp) 11391c: e8 cf fd fe ff call 1036f0 rtems_printf( printer, "--- Wall times are in seconds ---\n" ); 113921: b8 40 09 19 00 mov $0x190940,%eax 113926: 89 44 24 04 mov %eax,0x4(%esp) 11392a: 89 3c 24 mov %edi,(%esp) 11392d: e8 be fd fe ff call 1036f0 Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ rtems_printf( printer, 113932: b8 64 09 19 00 mov $0x190964,%eax 113937: 89 44 24 04 mov %eax,0x4(%esp) 11393b: 89 3c 24 mov %edi,(%esp) 11393e: e8 ad fd fe ff call 1036f0 /* * 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. */ maximum_id = _Rate_monotonic_Information.maximum_id; 113943: a1 80 18 1a 00 mov 0x1a1880,%eax 113948: 89 85 54 ff ff ff mov %eax,-0xac(%ebp) id &= ~OBJECTS_INDEX_MASK; 11394e: 89 c3 mov %eax,%ebx 113950: 81 e3 00 00 ff ff and $0xffff0000,%ebx id += (Objects_Id) OBJECTS_INDEX_MINIMUM << OBJECTS_INDEX_START_BIT; 113956: 43 inc %ebx for ( 113957: 39 d8 cmp %ebx,%eax 113959: 0f 83 54 01 00 00 jae 113ab3 <== ALWAYS TAKEN 11395f: e9 eb 01 00 00 jmp 113b4f <== NOT EXECUTED 113964: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 11396b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 11396f: 90 nop <== NOT EXECUTED struct timespec cpu_average; struct timespec *min_cpu = &the_stats.min_cpu_time; struct timespec *max_cpu = &the_stats.max_cpu_time; struct timespec *total_cpu = &the_stats.total_cpu_time; _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average ); 113970: 89 44 24 04 mov %eax,0x4(%esp) 113974: 8d b5 68 ff ff ff lea -0x98(%ebp),%esi 11397a: 89 74 24 08 mov %esi,0x8(%esp) 11397e: 8d 45 b8 lea -0x48(%ebp),%eax rtems_printf( printer, 113981: be d3 4d 62 10 mov $0x10624dd3,%esi _Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average ); 113986: 89 04 24 mov %eax,(%esp) 113989: e8 22 8e 00 00 call 11c7b0 <_Timespec_Divide_by_integer> rtems_printf( printer, 11398e: 8b 8d 70 ff ff ff mov -0x90(%ebp),%ecx 113994: 89 3c 24 mov %edi,(%esp) 113997: 89 c8 mov %ecx,%eax 113999: f7 ee imul %esi 11399b: 8b 85 68 ff ff ff mov -0x98(%ebp),%eax 1139a1: c1 f9 1f sar $0x1f,%ecx 1139a4: 89 44 24 20 mov %eax,0x20(%esp) 1139a8: c1 fa 06 sar $0x6,%edx 1139ab: 29 ca sub %ecx,%edx 1139ad: 8b 4d b4 mov -0x4c(%ebp),%ecx 1139b0: 89 54 24 28 mov %edx,0x28(%esp) 1139b4: 8b 95 6c ff ff ff mov -0x94(%ebp),%edx 1139ba: 89 c8 mov %ecx,%eax 1139bc: 89 54 24 24 mov %edx,0x24(%esp) 1139c0: f7 ee imul %esi 1139c2: 8b 45 ac mov -0x54(%ebp),%eax 1139c5: c1 f9 1f sar $0x1f,%ecx 1139c8: 89 44 24 14 mov %eax,0x14(%esp) 1139cc: c1 fa 06 sar $0x6,%edx 1139cf: 29 ca sub %ecx,%edx 1139d1: 8b 4d a8 mov -0x58(%ebp),%ecx 1139d4: 89 54 24 1c mov %edx,0x1c(%esp) 1139d8: 8b 55 b0 mov -0x50(%ebp),%edx 1139db: 89 c8 mov %ecx,%eax 1139dd: 89 54 24 18 mov %edx,0x18(%esp) 1139e1: f7 ee imul %esi 1139e3: 8b 45 a0 mov -0x60(%ebp),%eax 1139e6: c1 f9 1f sar $0x1f,%ecx 1139e9: 89 44 24 08 mov %eax,0x8(%esp) 1139ed: c1 fa 06 sar $0x6,%edx 1139f0: b8 fc 09 19 00 mov $0x1909fc,%eax 1139f5: 89 44 24 04 mov %eax,0x4(%esp) 1139f9: 29 ca sub %ecx,%edx 1139fb: 89 54 24 10 mov %edx,0x10(%esp) 1139ff: 8b 55 a4 mov -0x5c(%ebp),%edx 113a02: 89 54 24 0c mov %edx,0xc(%esp) 113a06: e8 e5 fc fe ff call 1036f0 struct timespec wall_average; struct timespec *min_wall = &the_stats.min_wall_time; struct timespec *max_wall = &the_stats.max_wall_time; struct timespec *total_wall = &the_stats.total_wall_time; _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average); 113a0b: 8d 85 68 ff ff ff lea -0x98(%ebp),%eax 113a11: 89 44 24 08 mov %eax,0x8(%esp) 113a15: 8b 45 98 mov -0x68(%ebp),%eax 113a18: 89 44 24 04 mov %eax,0x4(%esp) 113a1c: 8d 45 dc lea -0x24(%ebp),%eax 113a1f: 89 04 24 mov %eax,(%esp) 113a22: e8 89 8d 00 00 call 11c7b0 <_Timespec_Divide_by_integer> rtems_printf( printer, 113a27: 8b 8d 70 ff ff ff mov -0x90(%ebp),%ecx 113a2d: 89 3c 24 mov %edi,(%esp) 113a30: 89 c8 mov %ecx,%eax 113a32: f7 ee imul %esi 113a34: 8b 85 68 ff ff ff mov -0x98(%ebp),%eax 113a3a: c1 f9 1f sar $0x1f,%ecx 113a3d: 89 44 24 20 mov %eax,0x20(%esp) 113a41: c1 fa 06 sar $0x6,%edx 113a44: 29 ca sub %ecx,%edx 113a46: 8b 4d d8 mov -0x28(%ebp),%ecx 113a49: 89 54 24 28 mov %edx,0x28(%esp) 113a4d: 8b 95 6c ff ff ff mov -0x94(%ebp),%edx 113a53: 89 c8 mov %ecx,%eax 113a55: 89 54 24 24 mov %edx,0x24(%esp) 113a59: f7 ee imul %esi 113a5b: 8b 45 d0 mov -0x30(%ebp),%eax 113a5e: c1 f9 1f sar $0x1f,%ecx 113a61: 89 44 24 14 mov %eax,0x14(%esp) 113a65: c1 fa 06 sar $0x6,%edx 113a68: 29 ca sub %ecx,%edx 113a6a: 8b 4d cc mov -0x34(%ebp),%ecx 113a6d: 89 54 24 1c mov %edx,0x1c(%esp) 113a71: 8b 55 d4 mov -0x2c(%ebp),%edx 113a74: 89 c8 mov %ecx,%eax 113a76: 89 54 24 18 mov %edx,0x18(%esp) 113a7a: f7 ee imul %esi 113a7c: 8b 45 c4 mov -0x3c(%ebp),%eax 113a7f: c1 f9 1f sar $0x1f,%ecx 113a82: 89 44 24 08 mov %eax,0x8(%esp) 113a86: 89 d6 mov %edx,%esi 113a88: 8b 55 c8 mov -0x38(%ebp),%edx 113a8b: c1 fe 06 sar $0x6,%esi 113a8e: 29 ce sub %ecx,%esi 113a90: 89 74 24 10 mov %esi,0x10(%esp) 113a94: 89 54 24 0c mov %edx,0xc(%esp) 113a98: ba 20 0a 19 00 mov $0x190a20,%edx 113a9d: 89 54 24 04 mov %edx,0x4(%esp) 113aa1: e8 4a fc fe ff call 1036f0 ++id 113aa6: 43 inc %ebx for ( 113aa7: 39 9d 54 ff ff ff cmp %ebx,-0xac(%ebp) 113aad: 0f 82 9c 00 00 00 jb 113b4f <== NEVER TAKEN status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 113ab3: 89 1c 24 mov %ebx,(%esp) 113ab6: 8d 45 98 lea -0x68(%ebp),%eax 113ab9: 89 44 24 04 mov %eax,0x4(%esp) 113abd: e8 ae fb ff ff call 113670 if ( status != RTEMS_SUCCESSFUL ) 113ac2: 85 c0 test %eax,%eax 113ac4: 75 e0 jne 113aa6 (void) rtems_rate_monotonic_get_status( id, &the_status ); 113ac6: 89 1c 24 mov %ebx,(%esp) 113ac9: 8d 85 74 ff ff ff lea -0x8c(%ebp),%eax rtems_object_get_name( the_status.owner, sizeof(name), name ); 113acf: be 05 00 00 00 mov $0x5,%esi (void) rtems_rate_monotonic_get_status( id, &the_status ); 113ad4: 89 44 24 04 mov %eax,0x4(%esp) 113ad8: e8 a3 fc ff ff call 113780 rtems_object_get_name( the_status.owner, sizeof(name), name ); 113add: 8d 85 63 ff ff ff lea -0x9d(%ebp),%eax 113ae3: 89 44 24 08 mov %eax,0x8(%esp) 113ae7: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 113aed: 89 74 24 04 mov %esi,0x4(%esp) 113af1: 89 04 24 mov %eax,(%esp) 113af4: e8 d7 01 00 00 call 113cd0 rtems_printf( printer, 113af9: 8b 45 9c mov -0x64(%ebp),%eax 113afc: 89 5c 24 08 mov %ebx,0x8(%esp) 113b00: 89 3c 24 mov %edi,(%esp) 113b03: 89 44 24 14 mov %eax,0x14(%esp) 113b07: 8b 45 98 mov -0x68(%ebp),%eax 113b0a: 89 44 24 10 mov %eax,0x10(%esp) 113b0e: 8d 85 63 ff ff ff lea -0x9d(%ebp),%eax 113b14: 89 44 24 0c mov %eax,0xc(%esp) 113b18: b8 06 09 19 00 mov $0x190906,%eax 113b1d: 89 44 24 04 mov %eax,0x4(%esp) 113b21: e8 ca fb fe ff call 1036f0 if (the_stats.count == 0) { 113b26: 8b 45 98 mov -0x68(%ebp),%eax 113b29: 85 c0 test %eax,%eax 113b2b: 0f 85 3f fe ff ff jne 113970 <== NEVER TAKEN rtems_printf( printer, "\n" ); 113b31: 89 3c 24 mov %edi,(%esp) 113b34: b9 7c d4 19 00 mov $0x19d47c,%ecx ++id 113b39: 43 inc %ebx rtems_printf( printer, "\n" ); 113b3a: 89 4c 24 04 mov %ecx,0x4(%esp) 113b3e: e8 ad fb fe ff call 1036f0 for ( 113b43: 39 9d 54 ff ff ff cmp %ebx,-0xac(%ebp) 113b49: 0f 83 64 ff ff ff jae 113ab3 _Timespec_Get_seconds( &wall_average ), _Timespec_Get_nanoseconds( &wall_average ) / NANOSECONDS_DIVIDER ); } } } 113b4f: 81 c4 dc 00 00 00 add $0xdc,%esp 113b55: 5b pop %ebx 113b56: 5e pop %esi 113b57: 5f pop %edi 113b58: 5d pop %ebp 113b59: c3 ret 113b5a: 90 nop 113b5b: 90 nop 113b5c: 90 nop 113b5d: 90 nop 113b5e: 90 nop 113b5f: 90 nop =============================================================================== 00113b60 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 113b60: 55 push %ebp 113b61: 89 e5 mov %esp,%ebp 113b63: 56 push %esi 113b64: 53 push %ebx 113b65: 83 ec 10 sub $0x10,%esp _RTEMS_Lock_allocator(); 113b68: e8 53 0f 00 00 call 114ac0 <_RTEMS_Lock_allocator> /* * 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. */ maximum_id = _Rate_monotonic_Information.maximum_id; 113b6d: 8b 35 80 18 1a 00 mov 0x1a1880,%esi id &= ~OBJECTS_INDEX_MASK; 113b73: 89 f3 mov %esi,%ebx 113b75: 81 e3 00 00 ff ff and $0xffff0000,%ebx id += (Objects_Id) OBJECTS_INDEX_MINIMUM << OBJECTS_INDEX_START_BIT; 113b7b: 43 inc %ebx for ( 113b7c: 39 de cmp %ebx,%esi 113b7e: 72 0d jb 113b8d <== NEVER TAKEN id = _Objects_Get_minimum_id( maximum_id ) ; id <= maximum_id ; ++id ) { (void) rtems_rate_monotonic_reset_statistics( id ); 113b80: 89 1c 24 mov %ebx,(%esp) ++id 113b83: 43 inc %ebx (void) rtems_rate_monotonic_reset_statistics( id ); 113b84: e8 17 00 00 00 call 113ba0 for ( 113b89: 39 de cmp %ebx,%esi 113b8b: 73 f3 jae 113b80 } _Objects_Allocator_unlock(); } 113b8d: 83 c4 10 add $0x10,%esp 113b90: 5b pop %ebx 113b91: 5e pop %esi 113b92: 5d pop %ebp _RTEMS_Unlock_allocator(); 113b93: e9 48 0f 00 00 jmp 114ae0 <_RTEMS_Unlock_allocator> 113b98: 90 nop 113b99: 90 nop 113b9a: 90 nop 113b9b: 90 nop 113b9c: 90 nop 113b9d: 90 nop 113b9e: 90 nop 113b9f: 90 nop =============================================================================== 00113ba0 : #include rtems_status_code rtems_rate_monotonic_reset_statistics( rtems_id id ) { 113ba0: 55 push %ebp 113ba1: 89 e5 mov %esp,%ebp 113ba3: 83 ec 38 sub $0x38,%esp 113ba6: 89 5d f4 mov %ebx,-0xc(%ebp) _Objects_Get( id, lock_context, &_Rate_monotonic_Information ); 113ba9: 8d 45 e4 lea -0x1c(%ebp),%eax 113bac: bb 80 18 1a 00 mov $0x1a1880,%ebx 113bb1: 89 44 24 04 mov %eax,0x4(%esp) 113bb5: 8b 45 08 mov 0x8(%ebp),%eax 113bb8: 89 5c 24 08 mov %ebx,0x8(%esp) 113bbc: 89 75 f8 mov %esi,-0x8(%ebp) 113bbf: 89 7d fc mov %edi,-0x4(%ebp) 113bc2: 89 04 24 mov %eax,(%esp) 113bc5: e8 86 48 00 00 call 118450 <_Objects_Get> Rate_monotonic_Control *the_period; ISR_lock_Context lock_context; the_period = _Rate_monotonic_Get( id, &lock_context ); if ( the_period == NULL ) { 113bca: 85 c0 test %eax,%eax 113bcc: 0f 84 ae 00 00 00 je 113c80 ) { Rate_monotonic_Statistics *statistics; statistics = &the_period->Statistics; memset( statistics, 0, sizeof( *statistics ) ); 113bd2: 31 f6 xor %esi,%esi 113bd4: a8 01 test $0x1,%al 113bd6: 8d 48 60 lea 0x60(%eax),%ecx 113bd9: bb 38 00 00 00 mov $0x38,%ebx 113bde: 0f 85 bc 00 00 00 jne 113ca0 <== NEVER TAKEN 113be4: f6 c1 02 test $0x2,%cl 113be7: 0f 85 d3 00 00 00 jne 113cc0 <== NEVER TAKEN 113bed: 89 df mov %ebx,%edi 113bef: 31 d2 xor %edx,%edx 113bf1: 83 e7 f8 and $0xfffffff8,%edi 113bf4: 89 34 11 mov %esi,(%ecx,%edx,1) 113bf7: 89 74 11 04 mov %esi,0x4(%ecx,%edx,1) 113bfb: 83 c2 08 add $0x8,%edx 113bfe: 39 fa cmp %edi,%edx 113c00: 72 f2 jb 113bf4 113c02: 01 d1 add %edx,%ecx 113c04: f6 c3 04 test $0x4,%bl 113c07: 75 67 jne 113c70 <== NEVER TAKEN 113c09: f6 c3 02 test $0x2,%bl 113c0c: 75 52 jne 113c60 <== NEVER TAKEN 113c0e: f6 c3 01 test $0x1,%bl 113c11: 75 3d jne 113c50 <== NEVER TAKEN *_time = tstosbt(_ts); 113c13: c7 40 68 01 7d c1 25 movl $0x25c17d01,0x68(%eax) 113c1a: ba 01 7d c1 25 mov $0x25c17d01,%edx 113c1f: b9 ff ff ff 7f mov $0x7fffffff,%ecx 113c24: 89 90 80 00 00 00 mov %edx,0x80(%eax) 113c2a: 89 88 84 00 00 00 mov %ecx,0x84(%eax) 113c30: c7 40 6c ff ff ff 7f movl $0x7fffffff,0x6c(%eax) _ISR_lock_Release_and_ISR_enable( &the_period->Lock, lock_context ); 113c37: ff 75 e4 push -0x1c(%ebp) 113c3a: 9d popf _Rate_monotonic_Acquire_critical( the_period, &lock_context ); _Rate_monotonic_Reset_statistics( the_period ); _Rate_monotonic_Release( the_period, &lock_context ); return RTEMS_SUCCESSFUL; } 113c3b: 8b 5d f4 mov -0xc(%ebp),%ebx return RTEMS_SUCCESSFUL; 113c3e: 31 c0 xor %eax,%eax } 113c40: 8b 75 f8 mov -0x8(%ebp),%esi 113c43: 8b 7d fc mov -0x4(%ebp),%edi 113c46: 89 ec mov %ebp,%esp 113c48: 5d pop %ebp 113c49: c3 ret 113c4a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi memset( statistics, 0, sizeof( *statistics ) ); 113c50: c6 01 00 movb $0x0,(%ecx) <== NOT EXECUTED 113c53: eb be jmp 113c13 <== NOT EXECUTED 113c55: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 113c5c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 113c60: 66 c7 01 00 00 movw $0x0,(%ecx) <== NOT EXECUTED 113c65: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED 113c68: f6 c3 01 test $0x1,%bl <== NOT EXECUTED 113c6b: 74 a6 je 113c13 <== NOT EXECUTED 113c6d: eb e1 jmp 113c50 <== NOT EXECUTED 113c6f: 90 nop <== NOT EXECUTED 113c70: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED 113c76: 83 c1 04 add $0x4,%ecx <== NOT EXECUTED 113c79: f6 c3 02 test $0x2,%bl <== NOT EXECUTED 113c7c: 74 90 je 113c0e <== NOT EXECUTED 113c7e: eb e0 jmp 113c60 <== NOT EXECUTED 113c80: 8b 5d f4 mov -0xc(%ebp),%ebx return RTEMS_INVALID_ID; 113c83: b8 04 00 00 00 mov $0x4,%eax } 113c88: 8b 75 f8 mov -0x8(%ebp),%esi 113c8b: 8b 7d fc mov -0x4(%ebp),%edi 113c8e: 89 ec mov %ebp,%esp 113c90: 5d pop %ebp 113c91: c3 ret 113c92: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 113c99: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 113ca0: c6 40 60 00 movb $0x0,0x60(%eax) <== NOT EXECUTED 113ca4: 8d 48 61 lea 0x61(%eax),%ecx <== NOT EXECUTED 113ca7: bb 37 00 00 00 mov $0x37,%ebx <== NOT EXECUTED 113cac: e9 33 ff ff ff jmp 113be4 <== NOT EXECUTED 113cb1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 113cb8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 113cbf: 90 nop <== NOT EXECUTED 113cc0: 66 c7 01 00 00 movw $0x0,(%ecx) <== NOT EXECUTED 113cc5: 83 eb 02 sub $0x2,%ebx <== NOT EXECUTED 113cc8: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED 113ccb: e9 1d ff ff ff jmp 113bed <== NOT EXECUTED =============================================================================== 00106e60 : rtems_status_code rtems_scheduler_ident( rtems_name name, rtems_id *id ) { 106e60: 55 push %ebp *id = _Scheduler_Build_id( i ); sc = RTEMS_SUCCESSFUL; } } } else { sc = RTEMS_INVALID_ADDRESS; 106e61: b8 09 00 00 00 mov $0x9,%eax { 106e66: 89 e5 mov %esp,%ebp 106e68: 53 push %ebx 106e69: 8b 5d 0c mov 0xc(%ebp),%ebx 106e6c: 8b 4d 08 mov 0x8(%ebp),%ecx if ( id != NULL ) { 106e6f: 85 db test %ebx,%ebx 106e71: 74 34 je 106ea7 for ( i = 0 ; i < n && sc == RTEMS_INVALID_NAME ; ++i ) { 106e73: 31 d2 xor %edx,%edx sc = RTEMS_INVALID_NAME; 106e75: b8 03 00 00 00 mov $0x3,%eax 106e7a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi for ( i = 0 ; i < n && sc == RTEMS_INVALID_NAME ; ++i ) { 106e80: 85 d2 test %edx,%edx 106e82: 75 23 jne 106ea7 106e84: 83 f8 03 cmp $0x3,%eax 106e87: 75 1e jne 106ea7 <== NEVER TAKEN if ( scheduler->name == name ) { 106e89: 39 0d 44 44 12 00 cmp %ecx,0x124444 106e8f: b8 03 00 00 00 mov $0x3,%eax for ( i = 0 ; i < n && sc == RTEMS_INVALID_NAME ; ++i ) { 106e94: ba 01 00 00 00 mov $0x1,%edx if ( scheduler->name == name ) { 106e99: 75 e5 jne 106e80 *id = _Scheduler_Build_id( i ); 106e9b: c7 03 01 00 01 0f movl $0xf010001,(%ebx) sc = RTEMS_SUCCESSFUL; 106ea1: 31 c0 xor %eax,%eax for ( i = 0 ; i < n && sc == RTEMS_INVALID_NAME ; ++i ) { 106ea3: 85 d2 test %edx,%edx 106ea5: 74 dd je 106e84 <== NEVER TAKEN } return sc; } 106ea7: 5b pop %ebx 106ea8: 5d pop %ebp 106ea9: c3 ret 106eaa: 90 nop 106eab: 90 nop 106eac: 90 nop 106ead: 90 nop 106eae: 90 nop 106eaf: 90 nop =============================================================================== 00106dd0 : rtems_status_code rtems_scheduler_ident_by_processor_set( size_t cpusetsize, const cpu_set_t *cpuset, rtems_id *id ) { 106dd0: 55 push %ebp 106dd1: 89 e5 mov %esp,%ebp 106dd3: 83 ec 28 sub $0x28,%esp 106dd6: 89 5d fc mov %ebx,-0x4(%ebp) 106dd9: 8b 5d 10 mov 0x10(%ebp),%ebx Processor_mask set; Processor_mask_Copy_status status; uint32_t cpu_index; const Scheduler_Control *scheduler; if ( id == NULL ) { 106ddc: 85 db test %ebx,%ebx 106dde: 74 60 je 106e40 Processor_mask *dst, size_t src_size, const cpu_set_t *src ) { return _Processor_mask_Copy( 106de0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 106de3: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 106de7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 106dea: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 106dee: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 106df3: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 106df7: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 106dfa: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 106dfd: e8 9e 2f 00 00 call 109da0 <_Processor_mask_Copy> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; } status = _Processor_mask_From_cpu_set_t( &set, cpusetsize, cpuset ); if ( status == PROCESSOR_MASK_COPY_INVALID_SIZE ) { 106e02: 83 f8 03 cmp $0x3,%eax 106e05: 74 49 je 106e50 BIT_AND2( CPU_MAXIMUM_PROCESSORS, a, b, c ); 106e07: a1 48 4a 12 00 mov 0x124a48,%eax return (uint32_t) BIT_FLS( CPU_MAXIMUM_PROCESSORS, a ); 106e0c: 23 45 f4 and -0xc(%ebp),%eax 106e0f: 74 1f je 106e30 106e11: 89 04 24 mov %eax,(%esp) 106e14: e8 37 66 01 00 call 11d450 return RTEMS_INVALID_SIZE; } _Processor_mask_And( &set, &set, _SMP_Get_online_processors() ); cpu_index = _Processor_mask_Find_last_set( &set ); if ( cpu_index == 0 ) { 106e19: 85 c0 test %eax,%eax 106e1b: 74 13 je 106e30 <== NEVER TAKEN } #else _Assert( scheduler != NULL ); #endif *id = _Scheduler_Build_id( _Scheduler_Get_index( scheduler ) ); 106e1d: c7 03 01 00 01 0f movl $0xf010001,(%ebx) return RTEMS_SUCCESSFUL; } 106e23: 8b 5d fc mov -0x4(%ebp),%ebx 106e26: 89 ec mov %ebp,%esp 106e28: 5d pop %ebp return RTEMS_SUCCESSFUL; 106e29: 31 c0 xor %eax,%eax } 106e2b: c3 ret 106e2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 106e30: 8b 5d fc mov -0x4(%ebp),%ebx 106e33: 89 ec mov %ebp,%esp return RTEMS_INVALID_NAME; 106e35: b8 03 00 00 00 mov $0x3,%eax } 106e3a: 5d pop %ebp 106e3b: c3 ret 106e3c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 106e40: 8b 5d fc mov -0x4(%ebp),%ebx 106e43: 89 ec mov %ebp,%esp return RTEMS_INVALID_ADDRESS; 106e45: b8 09 00 00 00 mov $0x9,%eax } 106e4a: 5d pop %ebp 106e4b: c3 ret 106e4c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 106e50: 8b 5d fc mov -0x4(%ebp),%ebx 106e53: 89 ec mov %ebp,%esp return RTEMS_INVALID_SIZE; 106e55: b8 08 00 00 00 mov $0x8,%eax } 106e5a: 5d pop %ebp 106e5b: c3 ret 106e5c: 90 nop 106e5d: 90 nop 106e5e: 90 nop 106e5f: 90 nop =============================================================================== 00104140 : #endif #include rtems_status_code rtems_semaphore_flush( rtems_id id ) { 104140: 55 push %ebp Objects_Id id, Thread_queue_Context *queue_context ) { _Thread_queue_Context_initialize( queue_context ); return (Semaphore_Control *) _Objects_Get( 104141: b9 c0 53 12 00 mov $0x1253c0,%ecx 104146: 89 e5 mov %esp,%ebp 104148: 83 ec 48 sub $0x48,%esp 10414b: 89 5d fc mov %ebx,-0x4(%ebp) 10414e: 8b 45 08 mov 0x8(%ebp),%eax 104151: 8d 5d d4 lea -0x2c(%ebp),%ebx 104154: 89 4c 24 08 mov %ecx,0x8(%esp) 104158: 89 5c 24 04 mov %ebx,0x4(%esp) 10415c: 89 04 24 mov %eax,(%esp) 10415f: e8 0c 1d 00 00 call 105e70 <_Objects_Get> uintptr_t flags; Semaphore_Variant variant; the_semaphore = _Semaphore_Get( id, &queue_context ); if ( the_semaphore == NULL ) { 104164: 85 c0 test %eax,%eax 104166: 74 58 je 1041c0 return (uintptr_t) the_semaphore->Object.Node.previous; 104168: 8b 50 04 mov 0x4(%eax),%edx if ( 10416b: f6 c2 07 test $0x7,%dl 10416e: 74 40 je 1041b0 if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) { 104170: f6 c2 08 test $0x8,%dl return &_Thread_queue_Operations_FIFO; 104173: b9 b0 05 12 00 mov $0x1205b0,%ecx if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) { 104178: 74 26 je 1041a0 <== NEVER TAKEN || variant == SEMAPHORE_VARIANT_MUTEX_PRIORITY_CEILING || variant == SEMAPHORE_VARIANT_MUTEX_NO_PROTOCOL || variant == SEMAPHORE_VARIANT_SIMPLE_BINARY || variant == SEMAPHORE_VARIANT_COUNTING ); _Thread_queue_Flush_critical( 10417a: 89 5c 24 0c mov %ebx,0xc(%esp) 10417e: ba 60 73 10 00 mov $0x107360,%edx 104183: 83 c0 10 add $0x10,%eax 104186: 89 54 24 08 mov %edx,0x8(%esp) 10418a: 89 4c 24 04 mov %ecx,0x4(%esp) 10418e: 89 04 24 mov %eax,(%esp) 104191: e8 da 31 00 00 call 107370 <_Thread_queue_Flush_critical> ); break; } return RTEMS_SUCCESSFUL; } 104196: 8b 5d fc mov -0x4(%ebp),%ebx 104199: 89 ec mov %ebp,%esp 10419b: 5d pop %ebp return RTEMS_SUCCESSFUL; 10419c: 31 c0 xor %eax,%eax } 10419e: c3 ret 10419f: 90 nop return &_Thread_queue_Operations_priority; 1041a0: b9 9c 05 12 00 mov $0x12059c,%ecx <== NOT EXECUTED 1041a5: eb d3 jmp 10417a <== NOT EXECUTED 1041a7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 1041ae: 66 90 xchg %ax,%ax <== NOT EXECUTED return &_Thread_queue_Operations_priority_inherit; 1041b0: b9 88 05 12 00 mov $0x120588,%ecx 1041b5: eb c3 jmp 10417a 1041b7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1041be: 66 90 xchg %ax,%ax 1041c0: 8b 5d fc mov -0x4(%ebp),%ebx 1041c3: 89 ec mov %ebp,%esp return RTEMS_INVALID_ID; 1041c5: b8 04 00 00 00 mov $0x4,%eax } 1041ca: 5d pop %ebp 1041cb: c3 ret 1041cc: 90 nop 1041cd: 90 nop 1041ce: 90 nop 1041cf: 90 nop =============================================================================== 0010a7b0 : rtems_status_code rtems_semaphore_obtain( rtems_id id, rtems_option option_set, rtems_interval timeout ) { 10a7b0: 55 push %ebp Objects_Id id, Thread_queue_Context *queue_context ) { _Thread_queue_Context_initialize( queue_context ); return (Semaphore_Control *) _Objects_Get( 10a7b1: b9 80 c4 12 00 mov $0x12c480,%ecx 10a7b6: 89 e5 mov %esp,%ebp 10a7b8: 57 push %edi 10a7b9: 56 push %esi 10a7ba: 53 push %ebx 10a7bb: 8d 5d c4 lea -0x3c(%ebp),%ebx 10a7be: 83 ec 6c sub $0x6c,%esp 10a7c1: 89 4c 24 08 mov %ecx,0x8(%esp) 10a7c5: 8b 45 08 mov 0x8(%ebp),%eax 10a7c8: 89 5c 24 04 mov %ebx,0x4(%esp) 10a7cc: 89 04 24 mov %eax,(%esp) 10a7cf: e8 9c 2a 00 00 call 10d270 <_Objects_Get> Semaphore_Variant variant; Status_Control status; the_semaphore = _Semaphore_Get( id, &queue_context ); if ( the_semaphore == NULL ) { 10a7d4: 85 c0 test %eax,%eax 10a7d6: 0f 84 d4 01 00 00 je 10a9b0 */ RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait ( rtems_option option_set ) { return (option_set & RTEMS_NO_WAIT) ? true : false; 10a7dc: 0f b6 55 0c movzbl 0xc(%ebp),%edx 10a7e0: 8b 35 b8 0f 13 00 mov 0x130fb8,%esi 10a7e6: 80 e2 01 and $0x1,%dl return RTEMS_INVALID_ID; #endif } executing = _Thread_Executing; wait = !_Options_Is_no_wait( option_set ); 10a7e9: 80 f2 01 xor $0x1,%dl 10a7ec: 0f b6 fa movzbl %dl,%edi 10a7ef: 89 7d b0 mov %edi,-0x50(%ebp) if ( wait ) { 10a7f2: 75 7c jne 10a870 queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra; 10a7f4: c7 45 cc e0 e5 10 00 movl $0x10e5e0,-0x34(%ebp) return (uintptr_t) the_semaphore->Object.Node.previous; 10a7fb: 8b 78 04 mov 0x4(%eax),%edi 10a7fe: 89 7d ac mov %edi,-0x54(%ebp) return (Semaphore_Discipline) ( flags & 0x7 ); 10a801: 89 f9 mov %edi,%ecx flags = _Semaphore_Get_flags( the_semaphore ); variant = _Semaphore_Get_variant( flags ); switch ( variant ) { case SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY: status = _CORE_recursive_mutex_Seize( 10a803: 8d 78 10 lea 0x10(%eax),%edi 10a806: 83 e1 07 and $0x7,%ecx 10a809: 89 7d b4 mov %edi,-0x4c(%ebp) switch ( variant ) { 10a80c: 83 f9 01 cmp $0x1,%ecx 10a80f: 0f 84 cb 00 00 00 je 10a8e0 10a815: 83 f9 02 cmp $0x2,%ecx 10a818: 0f 84 42 01 00 00 je 10a960 10a81e: 85 c9 test %ecx,%ecx 10a820: 74 6e je 10a890 if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) { 10a822: f6 45 ac 08 testb $0x8,-0x54(%ebp) return &_Thread_queue_Operations_FIFO; 10a826: b9 18 77 12 00 mov $0x127718,%ecx if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) { 10a82b: 0f 84 1f 01 00 00 je 10a950 ) { _Assert( _ISR_Get_level() != 0 ); _CORE_semaphore_Acquire_critical( the_semaphore, queue_context ); if ( the_semaphore->count != 0 ) { 10a831: 8b 78 1c mov 0x1c(%eax),%edi 10a834: 85 ff test %edi,%edi 10a836: 0f 85 e4 00 00 00 jne 10a920 the_semaphore->count -= 1; _CORE_semaphore_Release( the_semaphore, queue_context ); return STATUS_SUCCESSFUL; } if ( !wait ) { 10a83c: 84 d2 test %dl,%dl 10a83e: 0f 84 8c 01 00 00 je 10a9d0 _Thread_queue_Context_set_thread_state( queue_context, STATES_WAITING_FOR_SEMAPHORE ); _Thread_queue_Enqueue( 10a844: 89 4c 24 04 mov %ecx,0x4(%esp) 10a848: 8b 45 b4 mov -0x4c(%ebp),%eax 10a84b: 89 5c 24 0c mov %ebx,0xc(%esp) 10a84f: 89 74 24 08 mov %esi,0x8(%esp) queue_context->thread_state = thread_state; 10a853: c7 45 c8 02 00 00 00 movl $0x2,-0x38(%ebp) 10a85a: 89 04 24 mov %eax,(%esp) 10a85d: e8 be 3d 00 00 call 10e620 <_Thread_queue_Enqueue> 10a862: 0f b6 4e 4c movzbl 0x4c(%esi),%ecx &queue_context ); break; } return _Status_Get( status ); 10a866: eb 61 jmp 10a8c9 10a868: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10a86f: 90 nop queue_context->enqueue_callout = _Thread_queue_Add_timeout_ticks; 10a870: c7 45 cc e0 f4 10 00 movl $0x10f4e0,-0x34(%ebp) queue_context->Timeout.ticks = ticks; 10a877: 8b 4d 10 mov 0x10(%ebp),%ecx 10a87a: 89 4d d0 mov %ecx,-0x30(%ebp) } 10a87d: e9 79 ff ff ff jmp 10a7fb 10a882: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10a889: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi return the_mutex->Wait_queue.Queue.owner; 10a890: 8b 50 14 mov 0x14(%eax),%edx if ( owner == NULL ) { 10a893: 85 d2 test %edx,%edx 10a895: 0f 84 45 01 00 00 je 10a9e0 if ( owner == executing ) { 10a89b: 39 d6 cmp %edx,%esi 10a89d: 0f 84 1d 01 00 00 je 10a9c0 return _CORE_mutex_Seize_slow( 10a8a3: 89 5c 24 10 mov %ebx,0x10(%esp) 10a8a7: 8b 45 b0 mov -0x50(%ebp),%eax 10a8aa: ba f0 76 12 00 mov $0x1276f0,%edx 10a8af: 89 74 24 08 mov %esi,0x8(%esp) 10a8b3: 89 54 24 04 mov %edx,0x4(%esp) 10a8b7: 89 44 24 0c mov %eax,0xc(%esp) 10a8bb: 8b 45 b4 mov -0x4c(%ebp),%eax 10a8be: 89 04 24 mov %eax,(%esp) 10a8c1: e8 5a 0d 00 00 call 10b620 <_CORE_mutex_Seize_slow> 10a8c6: 0f b6 c8 movzbl %al,%ecx } 10a8c9: 83 c4 6c add $0x6c,%esp 10a8cc: 89 c8 mov %ecx,%eax 10a8ce: 5b pop %ebx 10a8cf: 5e pop %esi 10a8d0: 5f pop %edi 10a8d1: 5d pop %ebp 10a8d2: c3 ret 10a8d3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10a8da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi return the_mutex->Wait_queue.Queue.owner; 10a8e0: 8b 50 14 mov 0x14(%eax),%edx _CORE_mutex_Acquire_critical( &the_mutex->Recursive.Mutex, queue_context ); owner = _CORE_mutex_Get_owner( &the_mutex->Recursive.Mutex ); if ( owner == NULL ) { 10a8e3: 85 d2 test %edx,%edx 10a8e5: 0f 84 15 01 00 00 je 10aa00 executing, queue_context ); } if ( owner == executing ) { 10a8eb: 39 d6 cmp %edx,%esi 10a8ed: 74 41 je 10a930 <== NEVER TAKEN status = ( *nested )( &the_mutex->Recursive ); _CORE_mutex_Release( &the_mutex->Recursive.Mutex, queue_context ); return status; } return _CORE_mutex_Seize_slow( 10a8ef: 89 5c 24 10 mov %ebx,0x10(%esp) 10a8f3: 8b 45 b0 mov -0x50(%ebp),%eax 10a8f6: 89 74 24 08 mov %esi,0x8(%esp) 10a8fa: 89 44 24 0c mov %eax,0xc(%esp) 10a8fe: b8 04 77 12 00 mov $0x127704,%eax 10a903: 89 44 24 04 mov %eax,0x4(%esp) 10a907: 8b 45 b4 mov -0x4c(%ebp),%eax 10a90a: 89 04 24 mov %eax,(%esp) 10a90d: e8 0e 0d 00 00 call 10b620 <_CORE_mutex_Seize_slow> 10a912: 83 c4 6c add $0x6c,%esp 10a915: 5b pop %ebx 10a916: 5e pop %esi 10a917: 0f b6 c8 movzbl %al,%ecx 10a91a: 5f pop %edi 10a91b: 89 c8 mov %ecx,%eax 10a91d: 5d pop %ebp 10a91e: c3 ret 10a91f: 90 nop the_semaphore->count -= 1; 10a920: 4f dec %edi 10a921: 89 78 1c mov %edi,0x1c(%eax) _ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context ); 10a924: ff 75 c4 push -0x3c(%ebp) 10a927: 9d popf return STATUS_SUCCESSFUL; 10a928: 31 c9 xor %ecx,%ecx 10a92a: eb 9d jmp 10a8c9 10a92c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi ++the_mutex->nest_level; 10a930: ff 40 1c incl 0x1c(%eax) 10a933: ff 75 c4 push -0x3c(%ebp) 10a936: 9d popf 10a937: 83 c4 6c add $0x6c,%esp 10a93a: 31 c9 xor %ecx,%ecx 10a93c: 5b pop %ebx 10a93d: 89 c8 mov %ecx,%eax 10a93f: 5e pop %esi 10a940: 5f pop %edi 10a941: 5d pop %ebp 10a942: c3 ret 10a943: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10a94a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi return &_Thread_queue_Operations_priority; 10a950: b9 04 77 12 00 mov $0x127704,%ecx 10a955: e9 d7 fe ff ff jmp 10a831 10a95a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) { 10a960: f6 45 ac 08 testb $0x8,-0x54(%ebp) return &_Thread_queue_Operations_FIFO; 10a964: b9 18 77 12 00 mov $0x127718,%ecx if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) { 10a969: 75 05 jne 10a970 return &_Thread_queue_Operations_priority; 10a96b: b9 04 77 12 00 mov $0x127704,%ecx return the_mutex->Wait_queue.Queue.owner; 10a970: 8b 50 14 mov 0x14(%eax),%edx if ( owner == NULL ) { 10a973: 85 d2 test %edx,%edx 10a975: 74 79 je 10a9f0 if ( owner == executing ) { 10a977: 39 d6 cmp %edx,%esi 10a979: 74 b5 je 10a930 <== NEVER TAKEN return _CORE_mutex_Seize_slow( 10a97b: 89 5c 24 10 mov %ebx,0x10(%esp) 10a97f: 8b 45 b0 mov -0x50(%ebp),%eax 10a982: 89 74 24 08 mov %esi,0x8(%esp) 10a986: 89 4c 24 04 mov %ecx,0x4(%esp) 10a98a: 89 44 24 0c mov %eax,0xc(%esp) 10a98e: 8b 45 b4 mov -0x4c(%ebp),%eax 10a991: 89 04 24 mov %eax,(%esp) 10a994: e8 87 0c 00 00 call 10b620 <_CORE_mutex_Seize_slow> 10a999: 83 c4 6c add $0x6c,%esp 10a99c: 5b pop %ebx 10a99d: 5e pop %esi 10a99e: 0f b6 c8 movzbl %al,%ecx 10a9a1: 5f pop %edi 10a9a2: 89 c8 mov %ecx,%eax 10a9a4: 5d pop %ebp 10a9a5: c3 ret 10a9a6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10a9ad: 8d 76 00 lea 0x0(%esi),%esi 10a9b0: 83 c4 6c add $0x6c,%esp return RTEMS_INVALID_ID; 10a9b3: b9 04 00 00 00 mov $0x4,%ecx } 10a9b8: 5b pop %ebx 10a9b9: 89 c8 mov %ecx,%eax 10a9bb: 5e pop %esi 10a9bc: 5f pop %edi 10a9bd: 5d pop %ebp 10a9be: c3 ret 10a9bf: 90 nop ++the_mutex->nest_level; 10a9c0: ff 40 1c incl 0x1c(%eax) 10a9c3: ff 75 c4 push -0x3c(%ebp) 10a9c6: 9d popf return status; 10a9c7: e9 fd fe ff ff jmp 10a8c9 10a9cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10a9d0: ff 75 c4 push -0x3c(%ebp) 10a9d3: 9d popf return STATUS_UNSATISFIED; 10a9d4: b9 0d 00 00 00 mov $0xd,%ecx 10a9d9: e9 eb fe ff ff jmp 10a8c9 10a9de: 66 90 xchg %ax,%ax the_mutex->Wait_queue.Queue.owner = owner; 10a9e0: 89 70 14 mov %esi,0x14(%eax) 10a9e3: ff 75 c4 push -0x3c(%ebp) 10a9e6: 9d popf return STATUS_SUCCESSFUL; 10a9e7: e9 dd fe ff ff jmp 10a8c9 10a9ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi the_mutex->Wait_queue.Queue.owner = owner; 10a9f0: 89 70 14 mov %esi,0x14(%eax) 10a9f3: ff 75 c4 push -0x3c(%ebp) 10a9f6: 9d popf return STATUS_SUCCESSFUL; 10a9f7: 31 c9 xor %ecx,%ecx 10a9f9: e9 cb fe ff ff jmp 10a8c9 10a9fe: 66 90 xchg %ax,%ax queue_context->Priority.update_count = 0; 10aa00: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) 10aa07: 8b 56 38 mov 0x38(%esi),%edx if ( 10aa0a: 8b 78 30 mov 0x30(%eax),%edi 10aa0d: 39 7a 14 cmp %edi,0x14(%edx) 10aa10: 8b 4a 18 mov 0x18(%edx),%ecx 10aa13: 1b 48 34 sbb 0x34(%eax),%ecx 10aa16: 72 40 jb 10aa58 the_mutex->Wait_queue.Queue.owner = owner; 10aa18: 89 70 14 mov %esi,0x14(%eax) _Thread_Priority_add( 10aa1b: 83 c0 20 add $0x20,%eax 10aa1e: 89 44 24 04 mov %eax,0x4(%esp) 10aa22: 89 5c 24 08 mov %ebx,0x8(%esp) 10aa26: 89 34 24 mov %esi,(%esp) 10aa29: e8 72 35 00 00 call 10dfa0 <_Thread_Priority_add> disable_level = cpu_self->thread_dispatch_disable_level; 10aa2e: a1 b0 0f 13 00 mov 0x130fb0,%eax cpu_self->thread_dispatch_disable_level = disable_level + 1; 10aa33: 40 inc %eax 10aa34: a3 b0 0f 13 00 mov %eax,0x130fb0 _ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context ); 10aa39: ff 75 c4 push -0x3c(%ebp) 10aa3c: 9d popf _Thread_Priority_update( queue_context ); 10aa3d: 89 1c 24 mov %ebx,(%esp) 10aa40: e8 db 36 00 00 call 10e120 <_Thread_Priority_update> _Thread_Dispatch_enable( cpu_self ); 10aa45: c7 04 24 a0 0f 13 00 movl $0x130fa0,(%esp) 10aa4c: e8 4f 39 00 00 call 10e3a0 <_Thread_Dispatch_enable> return STATUS_SUCCESSFUL; 10aa51: 31 c9 xor %ecx,%ecx 10aa53: e9 71 fe ff ff jmp 10a8c9 10aa58: ff 75 c4 push -0x3c(%ebp) 10aa5b: 9d popf return STATUS_MUTEX_CEILING_VIOLATED; 10aa5c: b9 13 00 00 00 mov $0x13,%ecx 10aa61: e9 63 fe ff ff jmp 10a8c9 10aa66: 90 nop 10aa67: 90 nop 10aa68: 90 nop 10aa69: 90 nop 10aa6a: 90 nop 10aa6b: 90 nop 10aa6c: 90 nop 10aa6d: 90 nop 10aa6e: 90 nop 10aa6f: 90 nop =============================================================================== 0010aa70 : #include #include rtems_status_code rtems_semaphore_release( rtems_id id ) { 10aa70: 55 push %ebp 10aa71: 89 e5 mov %esp,%ebp 10aa73: 83 ec 78 sub $0x78,%esp 10aa76: 89 5d f4 mov %ebx,-0xc(%ebp) return (Semaphore_Control *) _Objects_Get( 10aa79: 8b 45 08 mov 0x8(%ebp),%eax 10aa7c: bb 80 c4 12 00 mov $0x12c480,%ebx 10aa81: 89 75 f8 mov %esi,-0x8(%ebp) 10aa84: 8d 75 c4 lea -0x3c(%ebp),%esi 10aa87: 89 5c 24 08 mov %ebx,0x8(%esp) 10aa8b: 89 74 24 04 mov %esi,0x4(%esp) 10aa8f: 89 04 24 mov %eax,(%esp) 10aa92: 89 7d fc mov %edi,-0x4(%ebp) 10aa95: e8 d6 27 00 00 call 10d270 <_Objects_Get> Semaphore_Variant variant; Status_Control status; the_semaphore = _Semaphore_Get( id, &queue_context ); if ( the_semaphore == NULL ) { 10aa9a: 85 c0 test %eax,%eax 10aa9c: 0f 84 4e 02 00 00 je 10acf0 10aaa2: 89 c3 mov %eax,%ebx 10aaa4: a1 b8 0f 13 00 mov 0x130fb8,%eax return (uintptr_t) the_semaphore->Object.Node.previous; 10aaa9: 8b 53 04 mov 0x4(%ebx),%edx flags = _Semaphore_Get_flags( the_semaphore ); variant = _Semaphore_Get_variant( flags ); switch ( variant ) { case SEMAPHORE_VARIANT_MUTEX_INHERIT_PRIORITY: status = _CORE_recursive_mutex_Surrender( 10aaac: 8d 4b 10 lea 0x10(%ebx),%ecx 10aaaf: 89 4d b4 mov %ecx,-0x4c(%ebp) return (Semaphore_Discipline) ( flags & 0x7 ); 10aab2: 89 d7 mov %edx,%edi 10aab4: 83 e7 07 and $0x7,%edi switch ( variant ) { 10aab7: 83 ff 02 cmp $0x2,%edi 10aaba: 0f 84 e0 01 00 00 je 10aca0 10aac0: 0f 87 ba 00 00 00 ja 10ab80 10aac6: 85 ff test %edi,%edi 10aac8: 0f 84 32 01 00 00 je 10ac00 10aace: 4f dec %edi 10aacf: 90 nop 10aad0: 0f 85 5a 01 00 00 jne 10ac30 <== NEVER TAKEN Per_CPU_Control *cpu_self; Thread_Control *new_owner; _CORE_mutex_Acquire_critical( &the_mutex->Recursive.Mutex, queue_context ); if ( !_CORE_mutex_Is_owner( &the_mutex->Recursive.Mutex, executing ) ) { 10aad6: 3b 43 14 cmp 0x14(%ebx),%eax 10aad9: 0f 85 01 01 00 00 jne 10abe0 _CORE_mutex_Release( &the_mutex->Recursive.Mutex, queue_context ); return STATUS_NOT_OWNER; } nest_level = the_mutex->Recursive.nest_level; 10aadf: 8b 7b 1c mov 0x1c(%ebx),%edi if ( nest_level > 0 ) { 10aae2: 85 ff test %edi,%edi 10aae4: 0f 85 96 01 00 00 jne 10ac80 <== NEVER TAKEN _Thread_Resource_count_decrement( executing ); _Thread_queue_Context_clear_priority_updates( queue_context ); _Thread_Wait_acquire_default_critical( executing, &lock_context ); _Thread_Priority_remove( 10aaea: 89 04 24 mov %eax,(%esp) 10aaed: 8d 4b 20 lea 0x20(%ebx),%ecx 10aaf0: 89 74 24 08 mov %esi,0x8(%esp) 10aaf4: 89 4c 24 04 mov %ecx,0x4(%esp) queue_context->Priority.update_count = 0; 10aaf8: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) 10aaff: 89 4d b0 mov %ecx,-0x50(%ebp) 10ab02: e8 19 35 00 00 call 10e020 <_Thread_Priority_remove> RTEMS_INLINE_ROUTINE Thread_Control *_Thread_queue_First_locked( Thread_queue_Control *the_thread_queue, const Thread_queue_Operations *operations ) { Thread_queue_Heads *heads = the_thread_queue->Queue.heads; 10ab07: 8b 43 10 mov 0x10(%ebx),%eax if ( heads != NULL ) { 10ab0a: 85 c0 test %eax,%eax 10ab0c: 0f 84 38 02 00 00 je 10ad4a return ( *operations->first )( heads ); 10ab12: 89 04 24 mov %eax,(%esp) 10ab15: ff 15 14 77 12 00 call *0x127714 the_mutex->Wait_queue.Queue.owner = owner; 10ab1b: 89 43 14 mov %eax,0x14(%ebx) disable_level = cpu_self->thread_dispatch_disable_level; 10ab1e: 8b 1d b0 0f 13 00 mov 0x130fb0,%ebx cpu_self->thread_dispatch_disable_level = disable_level + 1; 10ab24: 43 inc %ebx cpu_self = _Thread_Dispatch_disable_critical( &queue_context->Lock_context.Lock_context ); if ( new_owner != NULL ) { 10ab25: 85 c0 test %eax,%eax 10ab27: 89 1d b0 0f 13 00 mov %ebx,0x130fb0 10ab2d: 0f 84 29 02 00 00 je 10ad5c <== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) if ( _Objects_Is_local_id( new_owner->Object.id ) ) #endif { _Thread_Resource_count_increment( new_owner ); _Thread_Priority_add( 10ab33: 89 04 24 mov %eax,(%esp) 10ab36: 8b 4d b0 mov -0x50(%ebp),%ecx 10ab39: 89 74 24 08 mov %esi,0x8(%esp) 10ab3d: 89 45 b0 mov %eax,-0x50(%ebp) 10ab40: 89 4c 24 04 mov %ecx,0x4(%esp) 10ab44: e8 57 34 00 00 call 10dfa0 <_Thread_Priority_add> &the_mutex->Priority_ceiling, queue_context ); } _Thread_queue_Extract_critical( 10ab49: 8b 45 b0 mov -0x50(%ebp),%eax 10ab4c: ba 04 77 12 00 mov $0x127704,%edx 10ab51: 89 74 24 0c mov %esi,0xc(%esp) 10ab55: 89 54 24 04 mov %edx,0x4(%esp) 10ab59: 89 44 24 08 mov %eax,0x8(%esp) 10ab5d: 8b 45 b4 mov -0x4c(%ebp),%eax 10ab60: 89 04 24 mov %eax,(%esp) 10ab63: e8 38 3c 00 00 call 10e7a0 <_Thread_queue_Extract_critical> ); } else { _CORE_mutex_Release( &the_mutex->Recursive.Mutex, queue_context ); } _Thread_Priority_update( queue_context ); 10ab68: 89 34 24 mov %esi,(%esp) 10ab6b: e8 b0 35 00 00 call 10e120 <_Thread_Priority_update> _Thread_Dispatch_enable( cpu_self ); 10ab70: c7 04 24 a0 0f 13 00 movl $0x130fa0,(%esp) 10ab77: e8 24 38 00 00 call 10e3a0 <_Thread_Dispatch_enable> return STATUS_SUCCESSFUL; 10ab7c: eb 6b jmp 10abe9 10ab7e: 66 90 xchg %ax,%ax 10ab80: 83 ff 03 cmp $0x3,%edi 10ab83: 0f 85 a7 00 00 00 jne 10ac30 if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) { 10ab89: f6 c2 08 test $0x8,%dl return &_Thread_queue_Operations_FIFO; 10ab8c: bf 18 77 12 00 mov $0x127718,%edi if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) { 10ab91: 0f 84 a9 01 00 00 je 10ad40 Thread_queue_Heads *heads = the_thread_queue->Queue.heads; 10ab97: 8b 43 10 mov 0x10(%ebx),%eax if ( heads != NULL ) { 10ab9a: 85 c0 test %eax,%eax 10ab9c: 0f 84 6e 01 00 00 je 10ad10 return ( *operations->first )( heads ); 10aba2: 89 04 24 mov %eax,(%esp) 10aba5: ff 57 10 call *0x10(%edi) if ( the_thread != NULL ) { 10aba8: 85 c0 test %eax,%eax 10abaa: 0f 84 60 01 00 00 je 10ad10 <== NEVER TAKEN _Thread_queue_Extract_critical( 10abb0: 89 44 24 08 mov %eax,0x8(%esp) 10abb4: 8b 45 b4 mov -0x4c(%ebp),%eax 10abb7: 89 74 24 0c mov %esi,0xc(%esp) 10abbb: 89 7c 24 04 mov %edi,0x4(%esp) 10abbf: 31 ff xor %edi,%edi 10abc1: 89 04 24 mov %eax,(%esp) 10abc4: e8 d7 3b 00 00 call 10e7a0 <_Thread_queue_Extract_critical> ); break; } return _Status_Get( status ); } 10abc9: 8b 5d f4 mov -0xc(%ebp),%ebx 10abcc: 89 f8 mov %edi,%eax 10abce: 8b 75 f8 mov -0x8(%ebp),%esi 10abd1: 8b 7d fc mov -0x4(%ebp),%edi 10abd4: 89 ec mov %ebp,%esp 10abd6: 5d pop %ebp 10abd7: c3 ret 10abd8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10abdf: 90 nop _ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context ); 10abe0: ff 75 c4 push -0x3c(%ebp) 10abe3: 9d popf return STATUS_NOT_OWNER; 10abe4: bf 17 00 00 00 mov $0x17,%edi 10abe9: 8b 5d f4 mov -0xc(%ebp),%ebx 10abec: 89 f8 mov %edi,%eax 10abee: 8b 75 f8 mov -0x8(%ebp),%esi 10abf1: 8b 7d fc mov -0x4(%ebp),%edi 10abf4: 89 ec mov %ebp,%esp 10abf6: 5d pop %ebp 10abf7: c3 ret 10abf8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10abff: 90 nop if ( !_CORE_mutex_Is_owner( &the_mutex->Mutex, executing ) ) { 10ac00: 3b 43 14 cmp 0x14(%ebx),%eax 10ac03: 75 db jne 10abe0 nest_level = the_mutex->nest_level; 10ac05: 8b 7b 1c mov 0x1c(%ebx),%edi if ( nest_level > 0 ) { 10ac08: 85 ff test %edi,%edi 10ac0a: 75 74 jne 10ac80 the_mutex->Wait_queue.Queue.owner = owner; 10ac0c: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) heads = the_mutex->Mutex.Wait_queue.Queue.heads; 10ac13: 8b 5b 10 mov 0x10(%ebx),%ebx if ( heads == NULL ) { 10ac16: 85 db test %ebx,%ebx 10ac18: 74 4b je 10ac65 _Thread_queue_Surrender( 10ac1a: b9 f0 76 12 00 mov $0x1276f0,%ecx 10ac1f: 89 4c 24 10 mov %ecx,0x10(%esp) 10ac23: e9 a9 00 00 00 jmp 10acd1 10ac28: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10ac2f: 90 nop 10ac30: f6 c2 08 test $0x8,%dl return &_Thread_queue_Operations_FIFO; 10ac33: bf 18 77 12 00 mov $0x127718,%edi if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) { 10ac38: 75 05 jne 10ac3f return &_Thread_queue_Operations_priority; 10ac3a: bf 04 77 12 00 mov $0x127704,%edi Thread_queue_Heads *heads = the_thread_queue->Queue.heads; 10ac3f: 8b 43 10 mov 0x10(%ebx),%eax if ( heads != NULL ) { 10ac42: 85 c0 test %eax,%eax 10ac44: 74 0e je 10ac54 return ( *operations->first )( heads ); 10ac46: 89 04 24 mov %eax,(%esp) 10ac49: ff 57 10 call *0x10(%edi) if ( the_thread != NULL ) { 10ac4c: 85 c0 test %eax,%eax 10ac4e: 0f 85 5c ff ff ff jne 10abb0 <== ALWAYS TAKEN if ( the_semaphore->count < maximum_count ) 10ac54: 8b 43 1c mov 0x1c(%ebx),%eax 10ac57: bf 0d 00 00 00 mov $0xd,%edi 10ac5c: 83 f8 ff cmp $0xffffffff,%eax 10ac5f: 0f 85 cb 00 00 00 jne 10ad30 _ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context ); 10ac65: ff 75 c4 push -0x3c(%ebp) 10ac68: 9d popf 10ac69: 8b 5d f4 mov -0xc(%ebp),%ebx 10ac6c: 89 f8 mov %edi,%eax 10ac6e: 8b 75 f8 mov -0x8(%ebp),%esi 10ac71: 8b 7d fc mov -0x4(%ebp),%edi 10ac74: 89 ec mov %ebp,%esp 10ac76: 5d pop %ebp 10ac77: c3 ret 10ac78: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10ac7f: 90 nop the_mutex->nest_level = nest_level - 1; 10ac80: 8d 57 ff lea -0x1(%edi),%edx 10ac83: 89 53 1c mov %edx,0x1c(%ebx) 10ac86: ff 75 c4 push -0x3c(%ebp) 10ac89: 9d popf return STATUS_SUCCESSFUL; 10ac8a: 31 ff xor %edi,%edi 10ac8c: 8b 5d f4 mov -0xc(%ebp),%ebx 10ac8f: 8b 75 f8 mov -0x8(%ebp),%esi 10ac92: 89 f8 mov %edi,%eax 10ac94: 8b 7d fc mov -0x4(%ebp),%edi 10ac97: 89 ec mov %ebp,%esp 10ac99: 5d pop %ebp 10ac9a: c3 ret 10ac9b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10ac9f: 90 nop if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) { 10aca0: f6 c2 08 test $0x8,%dl return &_Thread_queue_Operations_FIFO; 10aca3: b9 18 77 12 00 mov $0x127718,%ecx if ( _Semaphore_Get_discipline( flags ) == SEMAPHORE_DISCIPLINE_PRIORITY ) { 10aca8: 75 05 jne 10acaf return &_Thread_queue_Operations_priority; 10acaa: b9 04 77 12 00 mov $0x127704,%ecx if ( !_CORE_mutex_Is_owner( &the_mutex->Mutex, executing ) ) { 10acaf: 3b 43 14 cmp 0x14(%ebx),%eax 10acb2: 0f 85 28 ff ff ff jne 10abe0 <== NEVER TAKEN nest_level = the_mutex->nest_level; 10acb8: 8b 7b 1c mov 0x1c(%ebx),%edi if ( nest_level > 0 ) { 10acbb: 85 ff test %edi,%edi 10acbd: 75 c1 jne 10ac80 <== NEVER TAKEN the_mutex->Wait_queue.Queue.owner = owner; 10acbf: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) heads = the_mutex->Mutex.Wait_queue.Queue.heads; 10acc6: 8b 5b 10 mov 0x10(%ebx),%ebx if ( heads == NULL ) { 10acc9: 85 db test %ebx,%ebx 10accb: 74 98 je 10ac65 _Thread_queue_Surrender( 10accd: 89 4c 24 10 mov %ecx,0x10(%esp) 10acd1: 89 44 24 08 mov %eax,0x8(%esp) 10acd5: 8b 45 b4 mov -0x4c(%ebp),%eax 10acd8: 89 74 24 0c mov %esi,0xc(%esp) 10acdc: 89 5c 24 04 mov %ebx,0x4(%esp) 10ace0: 89 04 24 mov %eax,(%esp) 10ace3: e8 d8 3b 00 00 call 10e8c0 <_Thread_queue_Surrender> return STATUS_SUCCESSFUL; 10ace8: e9 fc fe ff ff jmp 10abe9 10aced: 8d 76 00 lea 0x0(%esi),%esi return RTEMS_INVALID_ID; 10acf0: bf 04 00 00 00 mov $0x4,%edi } 10acf5: 8b 5d f4 mov -0xc(%ebp),%ebx 10acf8: 8b 75 f8 mov -0x8(%ebp),%esi 10acfb: 89 f8 mov %edi,%eax 10acfd: 8b 7d fc mov -0x4(%ebp),%edi 10ad00: 89 ec mov %ebp,%esp 10ad02: 5d pop %ebp 10ad03: c3 ret 10ad04: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10ad0b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10ad0f: 90 nop 10ad10: 8b 43 1c mov 0x1c(%ebx),%eax 10ad13: 85 c0 test %eax,%eax 10ad15: 75 07 jne 10ad1e the_semaphore->count += 1; 10ad17: c7 43 1c 01 00 00 00 movl $0x1,0x1c(%ebx) 10ad1e: ff 75 c4 push -0x3c(%ebp) 10ad21: 9d popf 10ad22: 31 ff xor %edi,%edi 10ad24: e9 c0 fe ff ff jmp 10abe9 10ad29: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10ad30: 40 inc %eax 10ad31: 31 ff xor %edi,%edi 10ad33: 89 43 1c mov %eax,0x1c(%ebx) 10ad36: e9 2a ff ff ff jmp 10ac65 10ad3b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10ad3f: 90 nop 10ad40: bf 04 77 12 00 mov $0x127704,%edi 10ad45: e9 4d fe ff ff jmp 10ab97 the_mutex->Wait_queue.Queue.owner = owner; 10ad4a: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) disable_level = cpu_self->thread_dispatch_disable_level; 10ad51: a1 b0 0f 13 00 mov 0x130fb0,%eax cpu_self->thread_dispatch_disable_level = disable_level + 1; 10ad56: 40 inc %eax 10ad57: a3 b0 0f 13 00 mov %eax,0x130fb0 10ad5c: ff 75 c4 push -0x3c(%ebp) 10ad5f: 9d popf } 10ad60: e9 03 fe ff ff jmp 10ab68 10ad65: 90 nop 10ad66: 90 nop 10ad67: 90 nop 10ad68: 90 nop 10ad69: 90 nop 10ad6a: 90 nop 10ad6b: 90 nop 10ad6c: 90 nop 10ad6d: 90 nop 10ad6e: 90 nop 10ad6f: 90 nop =============================================================================== 00105090 : rtems_id semaphore_id, rtems_id scheduler_id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 105090: 55 push %ebp 105091: 89 e5 mov %esp,%ebp 105093: 83 ec 78 sub $0x78,%esp 105096: 89 5d f4 mov %ebx,-0xc(%ebp) const Scheduler_Control *scheduler; Semaphore_Control *the_semaphore; Thread_queue_Context queue_context; if ( old_priority == NULL ) { 105099: 8b 5d 14 mov 0x14(%ebp),%ebx { 10509c: 89 75 f8 mov %esi,-0x8(%ebp) 10509f: 89 7d fc mov %edi,-0x4(%ebp) if ( old_priority == NULL ) { 1050a2: 85 db test %ebx,%ebx 1050a4: 0f 84 86 01 00 00 je 105230 { uint32_t index; index = _Scheduler_Get_index_by_id( id ); if ( index >= _Scheduler_Count ) { 1050aa: 81 7d 0c 01 00 01 0f cmpl $0xf010001,0xc(%ebp) 1050b1: 0f 85 09 01 00 00 jne 1051c0 return (Semaphore_Control *) _Objects_Get( 1050b7: 8b 45 08 mov 0x8(%ebp),%eax 1050ba: 8d 5d c4 lea -0x3c(%ebp),%ebx 1050bd: b9 20 66 12 00 mov $0x126620,%ecx 1050c2: 89 4c 24 08 mov %ecx,0x8(%esp) 1050c6: 89 5c 24 04 mov %ebx,0x4(%esp) 1050ca: 89 04 24 mov %eax,(%esp) 1050cd: e8 fe 1e 00 00 call 106fd0 <_Objects_Get> return RTEMS_INVALID_ID; } the_semaphore = _Semaphore_Get( semaphore_id, &queue_context ); if ( the_semaphore == NULL ) { 1050d2: 89 45 b4 mov %eax,-0x4c(%ebp) 1050d5: 85 c0 test %eax,%eax 1050d7: 0f 84 e3 00 00 00 je 1051c0 return ( *scheduler->Operations.map_priority )( scheduler, priority ); 1050dd: c7 04 24 a0 11 12 00 movl $0x1211a0,(%esp) 1050e4: 8b 45 10 mov 0x10(%ebp),%eax 1050e7: 31 d2 xor %edx,%edx 1050e9: 89 54 24 08 mov %edx,0x8(%esp) 1050ed: 89 55 ac mov %edx,-0x54(%ebp) 1050f0: 89 44 24 04 mov %eax,0x4(%esp) 1050f4: 89 45 a8 mov %eax,-0x58(%ebp) 1050f7: ff 15 bc 11 12 00 call *0x1211bc if ( new_priority != RTEMS_CURRENT_PRIORITY && !valid ) { 1050fd: 8b 4d b4 mov -0x4c(%ebp),%ecx 105100: 89 55 a4 mov %edx,-0x5c(%ebp) 105103: 8b 55 10 mov 0x10(%ebp),%edx 105106: 89 45 a0 mov %eax,-0x60(%ebp) 105109: 85 d2 test %edx,%edx 10510b: 0f 84 8f 00 00 00 je 1051a0 105111: 8b 7d 10 mov 0x10(%ebp),%edi 105114: 39 3d dc 11 12 00 cmp %edi,0x1211dc 10511a: 8b 35 e0 11 12 00 mov 0x1211e0,%esi 105120: 1b 75 ac sbb -0x54(%ebp),%esi 105123: 0f 82 27 01 00 00 jb 105250 queue_context->Priority.update_count = 0; 105129: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) return (Semaphore_Discipline) ( flags & 0x7 ); 105130: 8b 71 04 mov 0x4(%ecx),%esi 105133: 83 e6 07 and $0x7,%esi switch ( variant ) { 105136: 4e dec %esi 105137: 0f 84 a3 00 00 00 je 1051e0 old_priority = 0; 10513d: 31 f6 xor %esi,%esi 10513f: 31 ff xor %edi,%edi sc = RTEMS_NOT_DEFINED; 105141: b9 0b 00 00 00 mov $0xb,%ecx 105146: 89 4d b4 mov %ecx,-0x4c(%ebp) disable_level = cpu_self->thread_dispatch_disable_level; 105149: a1 10 a4 12 00 mov 0x12a410,%eax cpu_self->thread_dispatch_disable_level = disable_level + 1; 10514e: 40 inc %eax 10514f: a3 10 a4 12 00 mov %eax,0x12a410 _ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context ); 105154: ff 75 c4 push -0x3c(%ebp) 105157: 9d popf _Thread_Priority_update( queue_context ); 105158: 89 1c 24 mov %ebx,(%esp) 10515b: e8 10 2d 00 00 call 107e70 <_Thread_Priority_update> _Thread_Dispatch_enable( cpu_self ); 105160: c7 04 24 00 a4 12 00 movl $0x12a400,(%esp) 105167: e8 f4 2e 00 00 call 108060 <_Thread_Dispatch_enable> return ( *scheduler->Operations.unmap_priority )( scheduler, priority ); 10516c: 89 7c 24 08 mov %edi,0x8(%esp) 105170: 89 74 24 04 mov %esi,0x4(%esp) 105174: c7 04 24 a0 11 12 00 movl $0x1211a0,(%esp) 10517b: ff 15 c0 11 12 00 call *0x1211c0 RTEMS_INLINE_ROUTINE rtems_task_priority _RTEMS_Priority_From_core( const Scheduler_Control *scheduler, Priority_Control priority ) { return (rtems_task_priority) 105181: 8b 7d 14 mov 0x14(%ebp),%edi return sc; 105184: 8b 4d b4 mov -0x4c(%ebp),%ecx 105187: 89 07 mov %eax,(%edi) scheduler, new_priority, old_priority, &queue_context ); } 105189: 8b 5d f4 mov -0xc(%ebp),%ebx 10518c: 89 c8 mov %ecx,%eax 10518e: 8b 75 f8 mov -0x8(%ebp),%esi 105191: 8b 7d fc mov -0x4(%ebp),%edi 105194: 89 ec mov %ebp,%esp 105196: 5d pop %ebp 105197: c3 ret 105198: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10519f: 90 nop queue_context->Priority.update_count = 0; 1051a0: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) 1051a7: 8b 41 04 mov 0x4(%ecx),%eax 1051aa: 83 e0 07 and $0x7,%eax switch ( variant ) { 1051ad: 48 dec %eax 1051ae: 75 8d jne 10513d <== NEVER TAKEN return the_mutex->Priority_ceiling.priority; 1051b0: 8b 71 30 mov 0x30(%ecx),%esi 1051b3: 8b 79 34 mov 0x34(%ecx),%edi sc = _Semaphore_Is_scheduler_valid( 1051b6: 31 c9 xor %ecx,%ecx 1051b8: eb 8c jmp 105146 1051ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi } 1051c0: 8b 5d f4 mov -0xc(%ebp),%ebx return RTEMS_INVALID_ID; 1051c3: b9 04 00 00 00 mov $0x4,%ecx } 1051c8: 8b 75 f8 mov -0x8(%ebp),%esi 1051cb: 89 c8 mov %ecx,%eax 1051cd: 8b 7d fc mov -0x4(%ebp),%edi 1051d0: 89 ec mov %ebp,%esp 1051d2: 5d pop %ebp 1051d3: c3 ret 1051d4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1051db: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 1051df: 90 nop return the_mutex->Wait_queue.Queue.owner; 1051e0: 8b 41 14 mov 0x14(%ecx),%eax return the_mutex->Priority_ceiling.priority; 1051e3: 8b 71 30 mov 0x30(%ecx),%esi 1051e6: 8b 79 34 mov 0x34(%ecx),%edi return the_mutex->Wait_queue.Queue.owner; 1051e9: 89 45 b4 mov %eax,-0x4c(%ebp) if ( owner != NULL ) { 1051ec: 85 c0 test %eax,%eax 1051ee: 74 70 je 105260 <== ALWAYS TAKEN RTEMS_INLINE_ROUTINE void _Thread_Wait_acquire( Thread_Control *the_thread, Thread_queue_Context *queue_context ) { _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 1051f0: 9c pushf <== NOT EXECUTED 1051f1: fa cli <== NOT EXECUTED 1051f2: 8f 45 a8 pop -0x58(%ebp) <== NOT EXECUTED 1051f5: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED 1051f8: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED node->priority = priority; 1051fb: 8b 45 a0 mov -0x60(%ebp),%eax <== NOT EXECUTED _Thread_Priority_change( 1051fe: 83 c1 20 add $0x20,%ecx <== NOT EXECUTED 105201: 8b 55 a4 mov -0x5c(%ebp),%edx <== NOT EXECUTED 105204: 89 41 10 mov %eax,0x10(%ecx) <== NOT EXECUTED _Thread_Priority_changed( 105207: 31 c0 xor %eax,%eax <== NOT EXECUTED 105209: 89 51 14 mov %edx,0x14(%ecx) <== NOT EXECUTED 10520c: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 105210: 8b 45 b4 mov -0x4c(%ebp),%eax <== NOT EXECUTED 105213: 89 5c 24 0c mov %ebx,0xc(%esp) <== NOT EXECUTED 105217: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED 10521b: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10521e: e8 cd 2b 00 00 call 107df0 <_Thread_Priority_changed> <== NOT EXECUTED Thread_Control *the_thread, Thread_queue_Context *queue_context ) { _Thread_Wait_release_critical( the_thread, queue_context ); _ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context ); 105223: ff 75 c4 push -0x3c(%ebp) <== NOT EXECUTED 105226: 9d popf <== NOT EXECUTED sc = _Semaphore_Is_scheduler_valid( 105227: 31 c9 xor %ecx,%ecx <== NOT EXECUTED } 105229: e9 18 ff ff ff jmp 105146 <== NOT EXECUTED 10522e: 66 90 xchg %ax,%ax <== NOT EXECUTED } 105230: 8b 5d f4 mov -0xc(%ebp),%ebx return RTEMS_INVALID_ADDRESS; 105233: b9 09 00 00 00 mov $0x9,%ecx } 105238: 8b 75 f8 mov -0x8(%ebp),%esi 10523b: 89 c8 mov %ecx,%eax 10523d: 8b 7d fc mov -0x4(%ebp),%edi 105240: 89 ec mov %ebp,%esp 105242: 5d pop %ebp 105243: c3 ret 105244: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10524b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10524f: 90 nop _ISR_lock_ISR_enable( &queue_context->Lock_context.Lock_context ); 105250: ff 75 c4 push -0x3c(%ebp) 105253: 9d popf return RTEMS_INVALID_PRIORITY; 105254: b9 13 00 00 00 mov $0x13,%ecx 105259: e9 2b ff ff ff jmp 105189 10525e: 66 90 xchg %ax,%ax the_mutex->Priority_ceiling.priority = priority_ceiling; 105260: 8b 45 a0 mov -0x60(%ebp),%eax 105263: 8b 55 a4 mov -0x5c(%ebp),%edx 105266: 89 41 30 mov %eax,0x30(%ecx) 105269: 89 51 34 mov %edx,0x34(%ecx) sc = _Semaphore_Is_scheduler_valid( 10526c: 31 c9 xor %ecx,%ecx 10526e: e9 d3 fe ff ff jmp 105146 105273: 90 nop 105274: 90 nop 105275: 90 nop 105276: 90 nop 105277: 90 nop 105278: 90 nop 105279: 90 nop 10527a: 90 nop 10527b: 90 nop 10527c: 90 nop 10527d: 90 nop 10527e: 90 nop 10527f: 90 nop =============================================================================== 00104950 : rtems_status_code rtems_signal_catch( rtems_asr_entry asr_handler, rtems_mode mode_set ) { 104950: 55 push %ebp 104951: 89 e5 mov %esp,%ebp 104953: 83 ec 0c sub $0xc,%esp 104956: 89 5d f4 mov %ebx,-0xc(%ebp) 104959: 8b 55 08 mov 0x8(%ebp),%edx 10495c: 89 75 f8 mov %esi,-0x8(%ebp) 10495f: 89 7d fc mov %edi,-0x4(%ebp) _ISR_lock_ISR_disable( lock_context ); 104962: 9c pushf 104963: fa cli 104964: 59 pop %ecx RTEMS_API_Control *api; ASR_Information *asr; ISR_lock_Context lock_context; executing = _Thread_State_acquire_for_executing( &lock_context ); api = executing->API_Extensions[ THREAD_API_RTEMS ]; 104965: a1 58 93 12 00 mov 0x129358,%eax asr = &api->Signal; if ( asr_handler != NULL ) { 10496a: 85 d2 test %edx,%edx api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10496c: 8b 80 08 01 00 00 mov 0x108(%eax),%eax if ( asr_handler != NULL ) { 104972: 74 1c je 104990 asr->mode_set = mode_set; asr->handler = asr_handler; 104974: 89 50 0c mov %edx,0xc(%eax) asr->mode_set = mode_set; 104977: 8b 7d 0c mov 0xc(%ebp),%edi 10497a: 89 78 10 mov %edi,0x10(%eax) _ISR_lock_ISR_enable( lock_context ); 10497d: 51 push %ecx 10497e: 9d popf _ASR_Initialize( asr ); } _Thread_State_release( executing, &lock_context ); return RTEMS_SUCCESSFUL; } 10497f: 8b 5d f4 mov -0xc(%ebp),%ebx 104982: 31 c0 xor %eax,%eax 104984: 8b 75 f8 mov -0x8(%ebp),%esi 104987: 8b 7d fc mov -0x4(%ebp),%edi 10498a: 89 ec mov %ebp,%esp 10498c: 5d pop %ebp 10498d: c3 ret 10498e: 66 90 xchg %ax,%ax memset(asr, 0, sizeof(*asr)); 104990: 31 db xor %ebx,%ebx 104992: a8 01 test $0x1,%al 104994: 8d 50 08 lea 0x8(%eax),%edx 104997: be 18 00 00 00 mov $0x18,%esi 10499c: 75 52 jne 1049f0 <== NEVER TAKEN 10499e: f6 c2 02 test $0x2,%dl 1049a1: 75 5d jne 104a00 <== NEVER TAKEN 1049a3: 89 f7 mov %esi,%edi 1049a5: 31 c0 xor %eax,%eax 1049a7: 83 e7 f8 and $0xfffffff8,%edi 1049aa: 89 1c 02 mov %ebx,(%edx,%eax,1) 1049ad: 89 5c 02 04 mov %ebx,0x4(%edx,%eax,1) 1049b1: 83 c0 08 add $0x8,%eax 1049b4: 39 f8 cmp %edi,%eax 1049b6: 72 f2 jb 1049aa 1049b8: 01 c2 add %eax,%edx 1049ba: f7 c6 04 00 00 00 test $0x4,%esi 1049c0: 74 09 je 1049cb <== ALWAYS TAKEN 1049c2: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED 1049c8: 83 c2 04 add $0x4,%edx <== NOT EXECUTED 1049cb: f7 c6 02 00 00 00 test $0x2,%esi 1049d1: 74 08 je 1049db <== ALWAYS TAKEN 1049d3: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED 1049d8: 83 c2 02 add $0x2,%edx <== NOT EXECUTED 1049db: 83 e6 01 and $0x1,%esi 1049de: 74 9d je 10497d <== ALWAYS TAKEN 1049e0: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED } 1049e3: eb 98 jmp 10497d <== NOT EXECUTED 1049e5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 1049ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED memset(asr, 0, sizeof(*asr)); 1049f0: c6 40 08 00 movb $0x0,0x8(%eax) <== NOT EXECUTED 1049f4: 8d 50 09 lea 0x9(%eax),%edx <== NOT EXECUTED 1049f7: be 17 00 00 00 mov $0x17,%esi <== NOT EXECUTED 1049fc: eb a0 jmp 10499e <== NOT EXECUTED 1049fe: 66 90 xchg %ax,%ax <== NOT EXECUTED 104a00: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED 104a05: 83 ee 02 sub $0x2,%esi <== NOT EXECUTED 104a08: 83 c2 02 add $0x2,%edx <== NOT EXECUTED 104a0b: eb 96 jmp 1049a3 <== NOT EXECUTED 104a0d: 90 nop 104a0e: 90 nop 104a0f: 90 nop =============================================================================== 0010c430 : [RTEMS_INTERRUPTED] = EINTR, [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_status_code_to_errno(rtems_status_code sc) { 10c430: 55 push %ebp 10c431: 89 e5 mov %esp,%ebp 10c433: 83 ec 08 sub $0x8,%esp 10c436: 89 5d fc mov %ebx,-0x4(%ebp) 10c439: 8b 45 08 mov 0x8(%ebp),%eax if (sc == RTEMS_SUCCESSFUL) { 10c43c: 85 c0 test %eax,%eax 10c43e: 75 10 jne 10c450 return 0; 10c440: 31 c0 xor %eax,%eax errno = eno; return -1; } } 10c442: 8b 5d fc mov -0x4(%ebp),%ebx 10c445: 89 ec mov %ebp,%esp 10c447: 5d pop %ebp 10c448: c3 ret 10c449: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) { 10c450: 83 f8 1d cmp $0x1d,%eax int eno = EINVAL; 10c453: bb 16 00 00 00 mov $0x16,%ebx if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) { 10c458: 77 07 ja 10c461 <== NEVER TAKEN eno = status_code_to_errno [sc]; 10c45a: 8b 1c 85 60 57 12 00 mov 0x125760(,%eax,4),%ebx errno = eno; 10c461: e8 2a cc 00 00 call 119090 <__errno> 10c466: 89 18 mov %ebx,(%eax) return -1; 10c468: b8 ff ff ff ff mov $0xffffffff,%eax 10c46d: eb d3 jmp 10c442 10c46f: 90 nop =============================================================================== 00111180 : #include rtems_status_code rtems_task_delete( rtems_id id ) { 111180: 55 push %ebp 111181: 89 e5 mov %esp,%ebp 111183: 83 ec 48 sub $0x48,%esp 111186: 89 5d fc mov %ebx,-0x4(%ebp) Thread_Control *the_thread; Thread_Close_context context; Thread_Control *executing; _Thread_queue_Context_initialize( &context.Base ); the_thread = _Thread_Get( id, &context.Base.Lock_context.Lock_context ); 111189: 8b 45 08 mov 0x8(%ebp),%eax 11118c: 8d 5d d0 lea -0x30(%ebp),%ebx 11118f: 89 5c 24 04 mov %ebx,0x4(%esp) 111193: 89 04 24 mov %eax,(%esp) 111196: e8 65 9a ff ff call 10ac00 <_Thread_Get> if ( the_thread == NULL ) { 11119b: 85 c0 test %eax,%eax 11119d: 74 71 je 111210 11119f: 8b 15 58 48 13 00 mov 0x134858,%edx return RTEMS_INVALID_ID; } executing = _Thread_Executing; if ( the_thread == executing ) { 1111a5: 39 d0 cmp %edx,%eax 1111a7: 74 27 je 1111d0 THREAD_LIFE_TERMINATING | THREAD_LIFE_DETACHED, NULL ); _Thread_Dispatch_enable( cpu_self ); } else { _Thread_Close( the_thread, executing, &context ); 1111a9: 89 5c 24 08 mov %ebx,0x8(%esp) 1111ad: 89 04 24 mov %eax,(%esp) 1111b0: 89 54 24 04 mov %edx,0x4(%esp) 1111b4: e8 f7 af ff ff call 10c1b0 <_Thread_Close> } return RTEMS_SUCCESSFUL; } 1111b9: 8b 5d fc mov -0x4(%ebp),%ebx 1111bc: 89 ec mov %ebp,%esp 1111be: 5d pop %ebp return RTEMS_SUCCESSFUL; 1111bf: 31 c0 xor %eax,%eax } 1111c1: c3 ret 1111c2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1111c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi disable_level = cpu_self->thread_dispatch_disable_level; 1111d0: 8b 15 50 48 13 00 mov 0x134850,%edx cpu_self->thread_dispatch_disable_level = disable_level + 1; 1111d6: 42 inc %edx 1111d7: 89 15 50 48 13 00 mov %edx,0x134850 _ISR_lock_ISR_enable( &context.Base.Lock_context.Lock_context ); 1111dd: ff 75 d0 push -0x30(%ebp) 1111e0: 9d popf _Thread_Exit( 1111e1: 89 04 24 mov %eax,(%esp) 1111e4: 31 d2 xor %edx,%edx 1111e6: b9 14 00 00 00 mov $0x14,%ecx 1111eb: 89 54 24 08 mov %edx,0x8(%esp) 1111ef: 89 4c 24 04 mov %ecx,0x4(%esp) 1111f3: e8 08 b0 ff ff call 10c200 <_Thread_Exit> _Thread_Dispatch_enable( cpu_self ); 1111f8: c7 04 24 40 48 13 00 movl $0x134840,(%esp) 1111ff: e8 8c 99 ff ff call 10ab90 <_Thread_Dispatch_enable> } 111204: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111207: 89 ec mov %ebp,%esp <== NOT EXECUTED 111209: 5d pop %ebp <== NOT EXECUTED return RTEMS_SUCCESSFUL; 11120a: 31 c0 xor %eax,%eax <== NOT EXECUTED } 11120c: c3 ret <== NOT EXECUTED 11120d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 111210: 8b 5d fc mov -0x4(%ebp),%ebx 111213: 89 ec mov %ebp,%esp return RTEMS_INVALID_ID; 111215: b8 04 00 00 00 mov $0x4,%eax } 11121a: 5d pop %ebp 11121b: c3 ret 11121c: 90 nop 11121d: 90 nop 11121e: 90 nop 11121f: 90 nop =============================================================================== 00107b30 : rtems_status_code rtems_task_get_affinity( rtems_id id, size_t cpusetsize, cpu_set_t *cpuset ) { 107b30: 55 push %ebp 107b31: 89 e5 mov %esp,%ebp 107b33: 83 ec 28 sub $0x28,%esp 107b36: 89 5d fc mov %ebx,-0x4(%ebp) 107b39: 8b 5d 10 mov 0x10(%ebp),%ebx Thread_Control *the_thread; ISR_lock_Context lock_context; Per_CPU_Control *cpu_self; bool ok; if ( cpuset == NULL ) { 107b3c: 85 db test %ebx,%ebx 107b3e: 74 60 je 107ba0 return RTEMS_INVALID_ADDRESS; } the_thread = _Thread_Get( id, &lock_context ); 107b40: 8d 45 f4 lea -0xc(%ebp),%eax 107b43: 89 44 24 04 mov %eax,0x4(%esp) 107b47: 8b 45 08 mov 0x8(%ebp),%eax 107b4a: 89 04 24 mov %eax,(%esp) 107b4d: e8 ae 39 00 00 call 10b500 <_Thread_Get> if ( the_thread == NULL ) { 107b52: 85 c0 test %eax,%eax 107b54: 74 5a je 107bb0 } cpu_self = _Thread_Dispatch_disable_critical( &lock_context ); _Thread_State_acquire_critical( the_thread, &lock_context ); ok = _Scheduler_Get_affinity( 107b56: 89 5c 24 08 mov %ebx,0x8(%esp) disable_level = cpu_self->thread_dispatch_disable_level; 107b5a: 8b 15 30 cf 12 00 mov 0x12cf30,%edx 107b60: 89 04 24 mov %eax,(%esp) cpu_self->thread_dispatch_disable_level = disable_level + 1; 107b63: 42 inc %edx 107b64: 89 15 30 cf 12 00 mov %edx,0x12cf30 107b6a: 8b 55 0c mov 0xc(%ebp),%edx 107b6d: 89 54 24 04 mov %edx,0x4(%esp) 107b71: e8 aa 2a 00 00 call 10a620 <_Scheduler_Get_affinity> 107b76: 88 c3 mov %al,%bl 107b78: ff 75 f4 push -0xc(%ebp) 107b7b: 9d popf cpusetsize, cpuset ); _Thread_State_release( the_thread, &lock_context ); _Thread_Dispatch_enable( cpu_self ); 107b7c: c7 04 24 20 cf 12 00 movl $0x12cf20,(%esp) 107b83: e8 08 39 00 00 call 10b490 <_Thread_Dispatch_enable> return ok ? RTEMS_SUCCESSFUL : RTEMS_INVALID_NUMBER; 107b88: 80 fb 01 cmp $0x1,%bl <== NOT EXECUTED } 107b8b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED return ok ? RTEMS_SUCCESSFUL : RTEMS_INVALID_NUMBER; 107b8e: 19 c0 sbb %eax,%eax <== NOT EXECUTED } 107b90: 89 ec mov %ebp,%esp <== NOT EXECUTED 107b92: 5d pop %ebp <== NOT EXECUTED return ok ? RTEMS_SUCCESSFUL : RTEMS_INVALID_NUMBER; 107b93: 83 e0 0a and $0xa,%eax <== NOT EXECUTED } 107b96: c3 ret <== NOT EXECUTED 107b97: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 107b9e: 66 90 xchg %ax,%ax <== NOT EXECUTED 107ba0: 8b 5d fc mov -0x4(%ebp),%ebx 107ba3: 89 ec mov %ebp,%esp return RTEMS_INVALID_ADDRESS; 107ba5: b8 09 00 00 00 mov $0x9,%eax } 107baa: 5d pop %ebp 107bab: c3 ret 107bac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 107bb0: 8b 5d fc mov -0x4(%ebp),%ebx 107bb3: 89 ec mov %ebp,%esp return RTEMS_INVALID_ID; 107bb5: b8 04 00 00 00 mov $0x4,%eax } 107bba: 5d pop %ebp 107bbb: c3 ret 107bbc: 90 nop 107bbd: 90 nop 107bbe: 90 nop 107bbf: 90 nop =============================================================================== 001072f0 : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 1072f0: 55 push %ebp 1072f1: 89 e5 mov %esp,%ebp 1072f3: 57 push %edi 1072f4: 56 push %esi 1072f5: 53 push %ebx 1072f6: 83 ec 2c sub $0x2c,%esp bool needs_asr_dispatching; rtems_mode old_mode; executing = _Thread_Get_executing(); if ( !previous_mode_set ) 1072f9: 8b 45 10 mov 0x10(%ebp),%eax { 1072fc: 8b 7d 0c mov 0xc(%ebp),%edi 1072ff: 8b 1d 98 31 13 00 mov 0x133198,%ebx if ( !previous_mode_set ) 107305: 85 c0 test %eax,%eax 107307: 0f 84 93 01 00 00 je 1074a0 */ api = executing->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 10730d: 80 bb 81 00 00 00 01 cmpb $0x1,0x81(%ebx) if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 107314: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10731a: 8b b3 08 01 00 00 mov 0x108(%ebx),%esi old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 107320: 19 c9 sbb %ecx,%ecx 107322: 81 e1 00 01 00 00 and $0x100,%ecx if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 107328: 85 c0 test %eax,%eax 10732a: 0f 85 30 01 00 00 jne 107460 old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 107330: 80 7e 08 01 cmpb $0x1,0x8(%esi) 107334: 89 4d e0 mov %ecx,-0x20(%ebp) 107337: 19 d2 sbb %edx,%edx 107339: 81 e2 00 04 00 00 and $0x400,%edx 10733f: 89 55 e4 mov %edx,-0x1c(%ebp) old_mode |= _ISR_Get_level(); 107342: e8 29 57 00 00 call 10ca70 <_CPU_ISR_Get_level> 107347: 8b 55 e4 mov -0x1c(%ebp),%edx 10734a: 8b 4d e0 mov -0x20(%ebp),%ecx 10734d: 09 c2 or %eax,%edx 10734f: 8b 45 10 mov 0x10(%ebp),%eax 107352: 09 d1 or %edx,%ecx 107354: 89 08 mov %ecx,(%eax) *previous_mode_set = old_mode; /* * These are generic thread scheduling characteristics. */ preempt_enabled = false; 107356: 31 c0 xor %eax,%eax if ( mask & RTEMS_PREEMPT_MASK ) { 107358: f7 c7 00 01 00 00 test $0x100,%edi 10735e: 74 1d je 10737d */ RTEMS_INLINE_ROUTINE bool _Modes_Is_preempt ( rtems_mode mode_set ) { return (mode_set & RTEMS_PREEMPT_MASK) == RTEMS_PREEMPT; 107360: 8b 55 08 mov 0x8(%ebp),%edx bool is_preempt_enabled = _Modes_Is_preempt( mode_set ); preempt_enabled = !executing->is_preemptible && is_preempt_enabled; 107363: 0f b6 83 81 00 00 00 movzbl 0x81(%ebx),%eax 10736a: c1 ea 08 shr $0x8,%edx 10736d: 83 f2 01 xor $0x1,%edx 107370: 34 01 xor $0x1,%al 107372: 80 e2 01 and $0x1,%dl executing->is_preemptible = is_preempt_enabled; 107375: 88 93 81 00 00 00 mov %dl,0x81(%ebx) preempt_enabled = !executing->is_preemptible && is_preempt_enabled; 10737b: 20 d0 and %dl,%al } if ( mask & RTEMS_TIMESLICE_MASK ) { 10737d: f7 c7 00 02 00 00 test $0x200,%edi 107383: 74 24 je 1073a9 if ( _Modes_Is_timeslice(mode_set) ) { 107385: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp) 10738c: 0f 84 de 00 00 00 je 107470 executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 107392: ba 01 00 00 00 mov $0x1,%edx 107397: 89 93 88 00 00 00 mov %edx,0x88(%ebx) executing->cpu_time_budget = 10739d: 8b 15 e0 95 12 00 mov 0x1295e0,%edx 1073a3: 89 93 84 00 00 00 mov %edx,0x84(%ebx) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) { 1073a9: f7 c7 01 00 00 00 test $0x1,%edi 1073af: 74 0b je 1073bc */ RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level ( rtems_mode mode_set ) { _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) ); 1073b1: f6 45 08 01 testb $0x1,0x8(%ebp) 1073b5: 0f 84 d5 00 00 00 je 107490 1073bb: fa cli /* * This is specific to the RTEMS API */ needs_asr_dispatching = false; if ( mask & RTEMS_ASR_MASK ) { 1073bc: 81 e7 00 04 00 00 and $0x400,%edi 1073c2: 74 7e je 107442 bool is_asr_enabled = !_Modes_Is_asr_disabled( mode_set ); 1073c4: 8b 55 08 mov 0x8(%ebp),%edx 1073c7: c1 ea 0a shr $0xa,%edx 1073ca: 83 f2 01 xor $0x1,%edx 1073cd: 80 e2 01 and $0x1,%dl _ISR_lock_ISR_disable( lock_context ); 1073d0: 9c pushf 1073d1: fa cli 1073d2: 59 pop %ecx _Thread_State_acquire( executing, &lock_context ); if ( is_asr_enabled != asr->is_enabled ) { 1073d3: 3a 56 08 cmp 0x8(%esi),%dl 1073d6: 74 68 je 107440 asr->is_enabled = is_asr_enabled; 1073d8: 88 56 08 mov %dl,0x8(%esi) RTEMS_INLINE_ROUTINE rtems_signal_set _ASR_Swap_signals( ASR_Information *asr ) { rtems_signal_set new_signals_posted; new_signals_posted = asr->signals_pending; 1073db: 8b 56 18 mov 0x18(%esi),%edx asr->signals_pending = asr->signals_posted; 1073de: 8b 7e 14 mov 0x14(%esi),%edi asr->signals_posted = new_signals_posted; 1073e1: 89 56 14 mov %edx,0x14(%esi) if ( _ASR_Swap_signals( asr ) != 0 ) { 1073e4: 85 d2 test %edx,%edx asr->signals_pending = asr->signals_posted; 1073e6: 89 7e 18 mov %edi,0x18(%esi) 1073e9: 74 55 je 107440 action->handler = handler; 1073eb: c7 46 28 e0 de 10 00 movl $0x10dee0,0x28(%esi) RTEMS_INLINE_ROUTINE void _Chain_Append_if_is_off_chain_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { if ( _Chain_Is_node_off_chain( the_node ) ) { 1073f2: 8b 56 20 mov 0x20(%esi),%edx } else { _Atomic_Fetch_or_ulong( &cpu_target->message, 0, ATOMIC_ORDER_RELEASE ); _CPU_SMP_Send_interrupt( _Per_CPU_Get_index( cpu_target ) ); } #else cpu_self->dispatch_necessary = true; 1073f5: b0 01 mov $0x1,%al 1073f7: a2 94 31 13 00 mov %al,0x133194 1073fc: 85 d2 test %edx,%edx 1073fe: 0f 84 ac 00 00 00 je 1074b0 <== ALWAYS TAKEN _ISR_lock_ISR_enable( lock_context ); 107404: 51 push %ecx <== NOT EXECUTED 107405: 9d popf <== NOT EXECUTED disable_level = cpu_self->thread_dispatch_disable_level; 107406: a1 90 31 13 00 mov 0x133190,%eax cpu_self->thread_dispatch_disable_level = disable_level + 1; 10740b: 40 inc %eax 10740c: a3 90 31 13 00 mov %eax,0x133190 _ISR_lock_ISR_disable( lock_context ); 107411: 9c pushf 107412: fa cli 107413: 5e pop %esi ( *scheduler->Operations.schedule )( scheduler, the_thread ); 107414: 89 5c 24 04 mov %ebx,0x4(%esp) 107418: c7 04 24 20 88 12 00 movl $0x128820,(%esp) 10741f: ff 15 28 88 12 00 call *0x128828 _ISR_lock_ISR_enable( lock_context ); 107425: 56 push %esi 107426: 9d popf cpu_self = _Thread_Dispatch_disable(); _Thread_State_acquire( executing, &lock_context ); _Scheduler_Schedule( executing ); _Thread_State_release( executing, &lock_context ); _Thread_Dispatch_direct( cpu_self ); 107427: c7 04 24 80 31 13 00 movl $0x133180,(%esp) 10742e: e8 ad 2e 00 00 call 10a2e0 <_Thread_Dispatch_direct> } return RTEMS_SUCCESSFUL; } 107433: 83 c4 2c add $0x2c,%esp return RTEMS_SUCCESSFUL; 107436: 31 d2 xor %edx,%edx } 107438: 5b pop %ebx 107439: 89 d0 mov %edx,%eax 10743b: 5e pop %esi 10743c: 5f pop %edi 10743d: 5d pop %ebp 10743e: c3 ret 10743f: 90 nop 107440: 51 push %ecx 107441: 9d popf return RTEMS_SUCCESSFUL; 107442: 31 d2 xor %edx,%edx if ( preempt_enabled || needs_asr_dispatching ) { 107444: 84 c0 test %al,%al 107446: 75 be jne 107406 } 107448: 83 c4 2c add $0x2c,%esp 10744b: 89 d0 mov %edx,%eax 10744d: 5b pop %ebx 10744e: 5e pop %esi 10744f: 5f pop %edi 107450: 5d pop %ebp 107451: c3 ret 107452: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 107459: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi old_mode |= RTEMS_TIMESLICE; 107460: 81 c9 00 02 00 00 or $0x200,%ecx 107466: e9 c5 fe ff ff jmp 107330 10746b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10746f: 90 nop executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 107470: 31 c9 xor %ecx,%ecx if ( mask & RTEMS_INTERRUPT_MASK ) { 107472: f7 c7 01 00 00 00 test $0x1,%edi executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 107478: 89 8b 88 00 00 00 mov %ecx,0x88(%ebx) if ( mask & RTEMS_INTERRUPT_MASK ) { 10747e: 0f 84 38 ff ff ff je 1073bc 107484: e9 28 ff ff ff jmp 1073b1 107489: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 107490: fb sti 107491: e9 26 ff ff ff jmp 1073bc 107496: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10749d: 8d 76 00 lea 0x0(%esi),%esi } 1074a0: 83 c4 2c add $0x2c,%esp return RTEMS_INVALID_ADDRESS; 1074a3: ba 09 00 00 00 mov $0x9,%edx } 1074a8: 5b pop %ebx 1074a9: 89 d0 mov %edx,%eax 1074ab: 5e pop %esi 1074ac: 5f pop %edi 1074ad: 5d pop %ebp 1074ae: c3 ret 1074af: 90 nop old_last = tail->previous; 1074b0: 8b 83 d8 00 00 00 mov 0xd8(%ebx),%eax _Chain_Append_if_is_off_chain_unprotected( 1074b6: 8d 56 20 lea 0x20(%esi),%edx return &the_chain->Tail.Node; 1074b9: 8d bb d4 00 00 00 lea 0xd4(%ebx),%edi 1074bf: 89 7e 20 mov %edi,0x20(%esi) tail->previous = the_node; 1074c2: 89 93 d8 00 00 00 mov %edx,0xd8(%ebx) old_last->next = the_node; 1074c8: 89 10 mov %edx,(%eax) the_node->previous = old_last; 1074ca: 89 46 24 mov %eax,0x24(%esi) _ISR_lock_ISR_enable( lock_context ); 1074cd: 51 push %ecx 1074ce: 9d popf if ( preempt_enabled || needs_asr_dispatching ) { 1074cf: e9 32 ff ff ff jmp 107406 1074d4: 90 nop 1074d5: 90 nop 1074d6: 90 nop 1074d7: 90 nop 1074d8: 90 nop 1074d9: 90 nop 1074da: 90 nop 1074db: 90 nop 1074dc: 90 nop 1074dd: 90 nop 1074de: 90 nop 1074df: 90 nop =============================================================================== 00104100 : rtems_status_code rtems_task_set_affinity( rtems_id id, size_t cpusetsize, const cpu_set_t *cpuset ) { 104100: 55 push %ebp 104101: 89 e5 mov %esp,%ebp 104103: 83 ec 28 sub $0x28,%esp 104106: 89 5d fc mov %ebx,-0x4(%ebp) 104109: 8b 5d 10 mov 0x10(%ebp),%ebx Thread_Control *the_thread; ISR_lock_Context lock_context; Per_CPU_Control *cpu_self; bool ok; if ( cpuset == NULL ) { 10410c: 85 db test %ebx,%ebx 10410e: 74 60 je 104170 return RTEMS_INVALID_ADDRESS; } the_thread = _Thread_Get( id, &lock_context ); 104110: 8d 45 f4 lea -0xc(%ebp),%eax 104113: 89 44 24 04 mov %eax,0x4(%esp) 104117: 8b 45 08 mov 0x8(%ebp),%eax 10411a: 89 04 24 mov %eax,(%esp) 10411d: e8 4e 21 00 00 call 106270 <_Thread_Get> if ( the_thread == NULL ) { 104122: 85 c0 test %eax,%eax 104124: 74 5a je 104180 } cpu_self = _Thread_Dispatch_disable_critical( &lock_context ); _Thread_State_acquire_critical( the_thread, &lock_context ); ok = _Scheduler_Set_affinity( 104126: 89 5c 24 08 mov %ebx,0x8(%esp) const ISR_lock_Context *lock_context ) { uint32_t disable_level; disable_level = cpu_self->thread_dispatch_disable_level; 10412a: 8b 15 30 81 12 00 mov 0x128130,%edx 104130: 89 04 24 mov %eax,(%esp) _Profiling_Thread_dispatch_disable_critical( cpu_self, disable_level, lock_context ); cpu_self->thread_dispatch_disable_level = disable_level + 1; 104133: 42 inc %edx 104134: 89 15 30 81 12 00 mov %edx,0x128130 10413a: 8b 55 0c mov 0xc(%ebp),%edx 10413d: 89 54 24 04 mov %edx,0x4(%esp) 104141: e8 2a 1d 00 00 call 105e70 <_Scheduler_Set_affinity> 104146: 88 c3 mov %al,%bl Thread_Control *the_thread, ISR_lock_Context *lock_context ) { _Thread_State_release_critical( the_thread, lock_context ); _ISR_lock_ISR_enable( lock_context ); 104148: ff 75 f4 push -0xc(%ebp) 10414b: 9d popf cpusetsize, cpuset ); _Thread_State_release( the_thread, &lock_context ); _Thread_Dispatch_enable( cpu_self ); 10414c: c7 04 24 20 81 12 00 movl $0x128120,(%esp) 104153: e8 88 20 00 00 call 1061e0 <_Thread_Dispatch_enable> return ok ? RTEMS_SUCCESSFUL : RTEMS_INVALID_NUMBER; 104158: 80 fb 01 cmp $0x1,%bl } 10415b: 8b 5d fc mov -0x4(%ebp),%ebx return ok ? RTEMS_SUCCESSFUL : RTEMS_INVALID_NUMBER; 10415e: 19 c0 sbb %eax,%eax } 104160: 89 ec mov %ebp,%esp 104162: 5d pop %ebp return ok ? RTEMS_SUCCESSFUL : RTEMS_INVALID_NUMBER; 104163: 83 e0 0a and $0xa,%eax } 104166: c3 ret 104167: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10416e: 66 90 xchg %ax,%ax 104170: 8b 5d fc mov -0x4(%ebp),%ebx 104173: 89 ec mov %ebp,%esp return RTEMS_INVALID_ADDRESS; 104175: b8 09 00 00 00 mov $0x9,%eax } 10417a: 5d pop %ebp 10417b: c3 ret 10417c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 104180: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 104183: 89 ec mov %ebp,%esp <== NOT EXECUTED return RTEMS_INVALID_ID; 104185: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED } 10418a: 5d pop %ebp <== NOT EXECUTED 10418b: c3 ret <== NOT EXECUTED 10418c: 90 nop 10418d: 90 nop 10418e: 90 nop 10418f: 90 nop =============================================================================== 00108010 : rtems_status_code rtems_task_set_scheduler( rtems_id task_id, rtems_id scheduler_id, rtems_task_priority priority ) { 108010: 55 push %ebp 108011: 89 e5 mov %esp,%ebp 108013: 83 ec 68 sub $0x68,%esp if ( index >= _Scheduler_Count ) { 108016: 81 7d 0c 01 00 01 0f cmpl $0xf010001,0xc(%ebp) 10801d: 89 5d f4 mov %ebx,-0xc(%ebp) 108020: 8b 5d 10 mov 0x10(%ebp),%ebx 108023: 89 75 f8 mov %esi,-0x8(%ebp) 108026: 89 7d fc mov %edi,-0x4(%ebp) 108029: 0f 85 91 00 00 00 jne 1080c0 return ( *scheduler->Operations.map_priority )( scheduler, priority ); 10802f: 89 5c 24 04 mov %ebx,0x4(%esp) *valid = ( priority <= scheduler->maximum_priority ); 108033: 31 d2 xor %edx,%edx 108035: 89 54 24 08 mov %edx,0x8(%esp) 108039: c7 04 24 00 44 12 00 movl $0x124400,(%esp) 108040: 89 5d b0 mov %ebx,-0x50(%ebp) 108043: 89 55 b4 mov %edx,-0x4c(%ebp) 108046: ff 15 1c 44 12 00 call *0x12441c if ( scheduler == NULL ) { return RTEMS_INVALID_ID; } core_priority = _RTEMS_Priority_To_core( scheduler, priority, &valid ); if ( !valid ) { 10804c: 39 1d 3c 44 12 00 cmp %ebx,0x12443c 108052: 89 45 ac mov %eax,-0x54(%ebp) 108055: a1 40 44 12 00 mov 0x124440,%eax 10805a: 89 d6 mov %edx,%esi 10805c: 1b 45 b4 sbb -0x4c(%ebp),%eax 10805f: 72 7f jb 1080e0 return RTEMS_INVALID_PRIORITY; } _Thread_queue_Context_initialize( &queue_context ); the_thread = _Thread_Get( task_id, &queue_context.Lock_context.Lock_context ); 108061: 8d 45 c4 lea -0x3c(%ebp),%eax 108064: 89 44 24 04 mov %eax,0x4(%esp) 108068: 8b 45 08 mov 0x8(%ebp),%eax 10806b: 89 04 24 mov %eax,(%esp) 10806e: e8 8d 34 00 00 call 10b500 <_Thread_Get> if ( the_thread == NULL ) { 108073: 85 c0 test %eax,%eax the_thread = _Thread_Get( task_id, &queue_context.Lock_context.Lock_context ); 108075: 89 c3 mov %eax,%ebx if ( the_thread == NULL ) { 108077: 74 47 je 1080c0 disable_level = cpu_self->thread_dispatch_disable_level; 108079: a1 30 cf 12 00 mov 0x12cf30,%eax ISR_lock_Context lock_context; const Scheduler_Control *old_scheduler; #endif if ( the_thread->Wait.queue != NULL ) { 10807e: 8b 53 54 mov 0x54(%ebx),%edx cpu_self->thread_dispatch_disable_level = disable_level + 1; 108081: 40 inc %eax 108082: a3 30 cf 12 00 mov %eax,0x12cf30 108087: 85 d2 test %edx,%edx 108089: b8 0c 00 00 00 mov $0xc,%eax 10808e: 74 70 je 108100 108090: 89 45 b0 mov %eax,-0x50(%ebp) 108093: ff 75 c4 push -0x3c(%ebp) 108096: 9d popf status = _Scheduler_Set( scheduler, the_thread, core_priority ); _Thread_State_release_critical( the_thread, &state_context ); _Thread_Wait_release( the_thread, &queue_context ); _Thread_Dispatch_enable( cpu_self ); 108097: c7 04 24 20 cf 12 00 movl $0x12cf20,(%esp) 10809e: e8 ed 33 00 00 call 10b490 <_Thread_Dispatch_enable> return _Status_Get( status ); 1080a3: 8b 45 b0 mov -0x50(%ebp),%eax } 1080a6: 8b 5d f4 mov -0xc(%ebp),%ebx 1080a9: 8b 75 f8 mov -0x8(%ebp),%esi 1080ac: 8b 7d fc mov -0x4(%ebp),%edi 1080af: 89 ec mov %ebp,%esp 1080b1: 5d pop %ebp 1080b2: c3 ret 1080b3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1080ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 1080c0: 8b 5d f4 mov -0xc(%ebp),%ebx return RTEMS_INVALID_ID; 1080c3: b8 04 00 00 00 mov $0x4,%eax } 1080c8: 8b 75 f8 mov -0x8(%ebp),%esi 1080cb: 8b 7d fc mov -0x4(%ebp),%edi 1080ce: 89 ec mov %ebp,%esp 1080d0: 5d pop %ebp 1080d1: c3 ret 1080d2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1080d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1080e0: 8b 5d f4 mov -0xc(%ebp),%ebx return RTEMS_INVALID_PRIORITY; 1080e3: b8 13 00 00 00 mov $0x13,%eax } 1080e8: 8b 75 f8 mov -0x8(%ebp),%esi 1080eb: 8b 7d fc mov -0x4(%ebp),%edi 1080ee: 89 ec mov %ebp,%esp 1080f0: 5d pop %ebp 1080f1: c3 ret 1080f2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1080f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi return the_thread->Scheduler.nodes; 108100: 8b 7b 38 mov 0x38(%ebx),%edi RTEMS_INLINE_ROUTINE void _Priority_Plain_extract( Priority_Aggregation *aggregation, Priority_Node *node ) { _RBTree_Extract( &aggregation->Contributors, &node->Node.RBTree ); 108103: 8d 43 20 lea 0x20(%ebx),%eax 108106: 89 44 24 04 mov %eax,0x4(%esp) 10810a: 89 45 b0 mov %eax,-0x50(%ebp) 10810d: 8d 4f 1c lea 0x1c(%edi),%ecx 108110: 89 0c 24 mov %ecx,(%esp) 108113: 89 4d a8 mov %ecx,-0x58(%ebp) 108116: e8 45 1d 00 00 call 109e60 <_RBTree_Extract> */ RTEMS_INLINE_ROUTINE bool _RBTree_Is_empty( const RBTree_Control *the_rbtree ) { return RB_EMPTY( the_rbtree ); 10811b: 8b 47 1c mov 0x1c(%edi),%eax _Priority_Plain_extract( &old_scheduler_node->Wait.Priority, &the_thread->Real_priority ); if ( 10811e: 85 c0 test %eax,%eax 108120: 75 6e jne 108190 <== NEVER TAKEN _Thread_Scheduler_process_requests( the_thread ); #else new_scheduler_node = old_scheduler_node; #endif the_thread->Start.initial_priority = priority; 108122: 89 b3 b8 00 00 00 mov %esi,0xb8(%ebx) 108128: 8b 45 ac mov -0x54(%ebp),%eax node->priority = priority; 10812b: 89 73 34 mov %esi,0x34(%ebx) RBTree_Control *the_rbtree, RBTree_Node *the_node ) { _Assert( _RBTree_Is_node_off_tree( the_node ) ); RB_ROOT( the_rbtree ) = the_node; 10812e: 8b 4d b0 mov -0x50(%ebp),%ecx 108131: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx) 108137: 89 43 30 mov %eax,0x30(%ebx) node->priority = priority; 10813a: 89 47 14 mov %eax,0x14(%edi) unsigned int seq; seq = _SMP_sequence_lock_Write_begin( &node->Priority.Lock ); #endif new_priority |= ( prepend_it ? 0 : SCHEDULER_PRIORITY_APPEND_FLAG ); 10813d: 83 c8 01 or $0x1,%eax 108140: 89 77 18 mov %esi,0x18(%edi) 108143: 89 4f 1c mov %ecx,0x1c(%edi) RB_PARENT( the_node, Node ) = NULL; 108146: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) RB_LEFT( the_node, Node ) = NULL; 10814d: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) RB_RIGHT( the_node, Node ) = NULL; 108154: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) RB_COLOR( the_node, Node ) = RB_BLACK; 10815b: c7 43 2c 00 00 00 00 movl $0x0,0x2c(%ebx) 108162: 89 47 28 mov %eax,0x28(%edi) ( *scheduler->Operations.update_priority )( 108165: 8b 43 38 mov 0x38(%ebx),%eax 108168: 89 77 2c mov %esi,0x2c(%edi) 10816b: 89 5c 24 04 mov %ebx,0x4(%esp) 10816f: c7 04 24 00 44 12 00 movl $0x124400,(%esp) 108176: 89 44 24 08 mov %eax,0x8(%esp) 10817a: ff 15 18 44 12 00 call *0x124418 } #endif _Scheduler_Node_set_priority( new_scheduler_node, priority, false ); _Scheduler_Update_priority( the_thread ); return STATUS_SUCCESSFUL; 108180: 31 c0 xor %eax,%eax 108182: e9 09 ff ff ff jmp 108090 108187: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10818e: 66 90 xchg %ax,%ax _Priority_Plain_insert( 108190: 8b 7b 30 mov 0x30(%ebx),%edi <== NOT EXECUTED 108193: 8b 73 34 mov 0x34(%ebx),%esi <== NOT EXECUTED link = _RBTree_Root_reference( the_rbtree ); parent = NULL; is_new_minimum = true; while ( *link != NULL ) { 108196: eb 0a jmp 1081a2 <== NOT EXECUTED 108198: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10819f: 90 nop <== NOT EXECUTED 1081a0: 89 d0 mov %edx,%eax <== NOT EXECUTED parent = *link; if ( ( *less )( key, parent ) ) { 1081a2: 3b 78 10 cmp 0x10(%eax),%edi <== NOT EXECUTED 1081a5: 89 f1 mov %esi,%ecx <== NOT EXECUTED 1081a7: 1b 48 14 sbb 0x14(%eax),%ecx <== NOT EXECUTED return &RB_LEFT( the_node, Node ); 1081aa: 89 c1 mov %eax,%ecx <== NOT EXECUTED if ( ( *less )( key, parent ) ) { 1081ac: 72 03 jb 1081b1 <== NOT EXECUTED return &RB_RIGHT( the_node, Node ); 1081ae: 8d 48 04 lea 0x4(%eax),%ecx <== NOT EXECUTED while ( *link != NULL ) { 1081b1: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 1081b3: 85 d2 test %edx,%edx <== NOT EXECUTED 1081b5: 75 e9 jne 1081a0 <== NOT EXECUTED RB_SET( child, parent, Node ); 1081b7: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED *link = child; 1081ba: 8b 45 b0 mov -0x50(%ebp),%eax <== NOT EXECUTED RB_SET( child, parent, Node ); 1081bd: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) <== NOT EXECUTED 1081c4: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED 1081cb: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx) <== NOT EXECUTED *link = child; 1081d2: 89 01 mov %eax,(%ecx) <== NOT EXECUTED is_new_minimum = false; } } _RBTree_Add_child( the_node, parent, link ); _RBTree_Insert_color( the_rbtree, the_node ); 1081d4: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 1081d8: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED 1081db: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1081de: e8 0d 21 00 00 call 10a2f0 <_RBTree_Insert_color> <== NOT EXECUTED return STATUS_RESOURCE_IN_USE; 1081e3: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED 1081e8: e9 a3 fe ff ff jmp 108090 <== NOT EXECUTED 1081ed: 90 nop 1081ee: 90 nop 1081ef: 90 nop =============================================================================== 00107cd0 : #include rtems_status_code rtems_task_suspend( rtems_id id ) { 107cd0: 55 push %ebp 107cd1: 89 e5 mov %esp,%ebp 107cd3: 83 ec 28 sub $0x28,%esp 107cd6: 89 5d fc mov %ebx,-0x4(%ebp) Thread_Control *the_thread; ISR_lock_Context lock_context; Per_CPU_Control *cpu_self; States_Control previous_state; the_thread = _Thread_Get( id, &lock_context ); 107cd9: 8d 45 f4 lea -0xc(%ebp),%eax 107cdc: 89 44 24 04 mov %eax,0x4(%esp) 107ce0: 8b 45 08 mov 0x8(%ebp),%eax 107ce3: 89 04 24 mov %eax,(%esp) 107ce6: e8 a5 2a 00 00 call 10a790 <_Thread_Get> if ( the_thread == NULL ) { 107ceb: 85 c0 test %eax,%eax 107ced: 74 51 je 107d40 <== NEVER TAKEN disable_level = cpu_self->thread_dispatch_disable_level; 107cef: 8b 15 30 d3 12 00 mov 0x12d330,%edx cpu_self->thread_dispatch_disable_level = disable_level + 1; 107cf5: 42 inc %edx 107cf6: 89 15 30 d3 12 00 mov %edx,0x12d330 return RTEMS_INVALID_ID; #endif } cpu_self = _Thread_Dispatch_disable_critical( &lock_context ); _ISR_lock_ISR_enable( &lock_context ); 107cfc: ff 75 f4 push -0xc(%ebp) 107cff: 9d popf previous_state = _Thread_Set_state( the_thread, STATES_SUSPENDED ); 107d00: 89 04 24 mov %eax,(%esp) 107d03: ba 00 80 00 00 mov $0x8000,%edx 107d08: 89 54 24 04 mov %edx,0x4(%esp) 107d0c: e8 9f 43 00 00 call 10c0b0 <_Thread_Set_state> _Thread_Dispatch_enable( cpu_self ); 107d11: c7 04 24 20 d3 12 00 movl $0x12d320,(%esp) previous_state = _Thread_Set_state( the_thread, STATES_SUSPENDED ); 107d18: 89 c3 mov %eax,%ebx _Thread_Dispatch_enable( cpu_self ); 107d1a: e8 01 2a 00 00 call 10a720 <_Thread_Dispatch_enable> return _States_Is_suspended( previous_state ) ? RTEMS_ALREADY_SUSPENDED : RTEMS_SUCCESSFUL; 107d1f: 89 d8 mov %ebx,%eax 107d21: 25 00 80 00 00 and $0x8000,%eax 107d26: 74 05 je 107d2d 107d28: b8 0f 00 00 00 mov $0xf,%eax } 107d2d: 8b 5d fc mov -0x4(%ebp),%ebx 107d30: 89 ec mov %ebp,%esp 107d32: 5d pop %ebp 107d33: c3 ret 107d34: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 107d3b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 107d3f: 90 nop 107d40: 8b 5d fc mov -0x4(%ebp),%ebx 107d43: 89 ec mov %ebp,%esp return RTEMS_INVALID_ID; 107d45: b8 04 00 00 00 mov $0x4,%eax } 107d4a: 5d pop %ebp 107d4b: c3 ret 107d4c: 90 nop 107d4d: 90 nop 107d4e: 90 nop 107d4f: 90 nop