RTEMS-6
Annotated Report
sapi
Sun Feb 28 23:01:43 2021
001080e0 <_IO_Initialize_all_drivers>:
#include <rtems/ioimpl.h>
bool _IO_All_drivers_initialized;
void _IO_Initialize_all_drivers( void )
{
1080e0: 55 push %ebp
rtems_device_major_number major;
_IO_All_drivers_initialized = true;
1080e1: b1 01 mov $0x1,%cl
{
1080e3: 89 e5 mov %esp,%ebp
1080e5: 56 push %esi
1080e6: 53 push %ebx
1080e7: 83 ec 10 sub $0x10,%esp
_IO_All_drivers_initialized = true;
1080ea: 88 0d 18 48 13 00 mov %cl,0x134818
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
1080f0: 8b 35 70 a9 12 00 mov 0x12a970,%esi
1080f6: 85 f6 test %esi,%esi
1080f8: 74 1f je 108119 <_IO_Initialize_all_drivers+0x39> <== NEVER TAKEN
1080fa: 31 db xor %ebx,%ebx
1080fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
(void) rtems_io_initialize( major, 0, NULL );
108100: 89 1c 24 mov %ebx,(%esp)
108103: 31 c0 xor %eax,%eax
108105: 31 d2 xor %edx,%edx
108107: 89 44 24 08 mov %eax,0x8(%esp)
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
10810b: 43 inc %ebx
(void) rtems_io_initialize( major, 0, NULL );
10810c: 89 54 24 04 mov %edx,0x4(%esp)
108110: e8 0b 00 00 00 call 108120 <rtems_io_initialize>
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
108115: 39 f3 cmp %esi,%ebx
108117: 75 e7 jne 108100 <_IO_Initialize_all_drivers+0x20>
}
108119: 83 c4 10 add $0x10,%esp
10811c: 5b pop %ebx
10811d: 5e pop %esi
10811e: 5d pop %ebp
10811f: c3 ret
00105340 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
105340: 55 push %ebp
105341: 89 e5 mov %esp,%ebp
105343: 57 push %edi
105344: 56 push %esi
105345: 53 push %ebx
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
105346: 8d 75 e4 lea -0x1c(%ebp),%esi
{
105349: 83 ec 2c sub $0x2c,%esp
10534c: 8b 5d 08 mov 0x8(%ebp),%ebx
10534f: 90 nop
&& (node = rtems_chain_get( chain )) == NULL
105350: 89 1c 24 mov %ebx,(%esp)
105353: e8 a8 00 00 00 call 105400 <rtems_chain_get>
105358: 85 c0 test %eax,%eax
10535a: 89 c7 mov %eax,%edi
10535c: 75 32 jne 105390 <rtems_chain_get_with_wait+0x50>
sc = rtems_event_receive(
10535e: 89 74 24 0c mov %esi,0xc(%esp) <== NOT EXECUTED
105362: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
105365: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
105369: 31 c0 xor %eax,%eax <== NOT EXECUTED
10536b: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10536f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
105372: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
105375: e8 d6 fa ff ff call 104e50 <rtems_event_receive> <== NOT EXECUTED
while (
10537a: 85 c0 test %eax,%eax
10537c: 74 d2 je 105350 <rtems_chain_get_with_wait+0x10> <== NEVER TAKEN
timeout,
&out
);
}
*node_ptr = node;
10537e: 8b 4d 14 mov 0x14(%ebp),%ecx
105381: 89 39 mov %edi,(%ecx)
return sc;
}
105383: 83 c4 2c add $0x2c,%esp
105386: 5b pop %ebx
105387: 5e pop %esi
105388: 5f pop %edi
105389: 5d pop %ebp
10538a: c3 ret
10538b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10538f: 90 nop
*node_ptr = node;
105390: 8b 4d 14 mov 0x14(%ebp),%ecx
105393: 31 c0 xor %eax,%eax
105395: 89 39 mov %edi,(%ecx)
}
105397: 83 c4 2c add $0x2c,%esp
10539a: 5b pop %ebx
10539b: 5e pop %esi
10539c: 5f pop %edi
10539d: 5d pop %ebp
10539e: c3 ret
10539f: 90 nop
00105770 <rtems_configuration_get_maximum_barriers>:
return information->objects_per_block != 0;
105770: 0f b7 05 d2 74 12 00 movzwl 0x1274d2,%eax
#include <rtems/rtems/timerimpl.h>
#include <rtems/score/objectimpl.h>
static uint32_t get_config_max( const Objects_Information *info )
{
if ( _Objects_Is_auto_extend( info ) ) {
105777: 85 c0 test %eax,%eax
105779: 75 15 jne 105790 <rtems_configuration_get_maximum_barriers+0x20><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Get_index(
Objects_Id id
)
{
return
10577b: 0f b7 05 c0 74 12 00 movzwl 0x1274c0,%eax
}
uint32_t rtems_configuration_get_maximum_barriers( void )
{
return get_config_max( &_Barrier_Information );
}
105782: c3 ret
105783: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10578a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
105790: 0d 00 00 00 80 or $0x80000000,%eax <== NOT EXECUTED
105795: c3 ret <== NOT EXECUTED
105796: 90 nop
105797: 90 nop
105798: 90 nop
105799: 90 nop
10579a: 90 nop
10579b: 90 nop
10579c: 90 nop
10579d: 90 nop
10579e: 90 nop
10579f: 90 nop
00114690 <rtems_configuration_get_maximum_extensions>:
114690: 0f b7 05 32 1d 1a 00 movzwl 0x1a1d32,%eax <== NOT EXECUTED
if ( _Objects_Is_auto_extend( info ) ) {
114697: 85 c0 test %eax,%eax <== NOT EXECUTED
114699: 75 15 jne 1146b0 <rtems_configuration_get_maximum_extensions+0x20><== NOT EXECUTED
11469b: 0f b7 05 20 1d 1a 00 movzwl 0x1a1d20,%eax <== NOT EXECUTED
uint32_t rtems_configuration_get_maximum_extensions( void )
{
return get_config_max( &_Extension_Information );
}
1146a2: c3 ret <== NOT EXECUTED
1146a3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1146aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
1146b0: 0d 00 00 00 80 or $0x80000000,%eax <== NOT EXECUTED
1146b5: c3 ret <== NOT EXECUTED
1146b6: 90 nop
1146b7: 90 nop
1146b8: 90 nop
1146b9: 90 nop
1146ba: 90 nop
1146bb: 90 nop
1146bc: 90 nop
1146bd: 90 nop
1146be: 90 nop
1146bf: 90 nop
001057a0 <rtems_configuration_get_maximum_message_queues>:
1057a0: 0f b7 05 52 75 12 00 movzwl 0x127552,%eax
if ( _Objects_Is_auto_extend( info ) ) {
1057a7: 85 c0 test %eax,%eax
1057a9: 75 15 jne 1057c0 <rtems_configuration_get_maximum_message_queues+0x20><== NEVER TAKEN
1057ab: 0f b7 05 40 75 12 00 movzwl 0x127540,%eax
}
uint32_t rtems_configuration_get_maximum_message_queues( void )
{
return get_config_max( &_Message_queue_Information );
}
1057b2: c3 ret
1057b3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1057ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
1057c0: 0d 00 00 00 80 or $0x80000000,%eax <== NOT EXECUTED
1057c5: c3 ret <== NOT EXECUTED
1057c6: 90 nop
1057c7: 90 nop
1057c8: 90 nop
1057c9: 90 nop
1057ca: 90 nop
1057cb: 90 nop
1057cc: 90 nop
1057cd: 90 nop
1057ce: 90 nop
1057cf: 90 nop
001057d0 <rtems_configuration_get_maximum_partitions>:
1057d0: 0f b7 05 92 75 12 00 movzwl 0x127592,%eax
if ( _Objects_Is_auto_extend( info ) ) {
1057d7: 85 c0 test %eax,%eax
1057d9: 75 15 jne 1057f0 <rtems_configuration_get_maximum_partitions+0x20><== NEVER TAKEN
1057db: 0f b7 05 80 75 12 00 movzwl 0x127580,%eax
uint32_t rtems_configuration_get_maximum_partitions( void )
{
return get_config_max( &_Partition_Information );
}
1057e2: c3 ret
1057e3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1057ea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
1057f0: 0d 00 00 00 80 or $0x80000000,%eax <== NOT EXECUTED
1057f5: c3 ret <== NOT EXECUTED
1057f6: 90 nop
1057f7: 90 nop
1057f8: 90 nop
1057f9: 90 nop
1057fa: 90 nop
1057fb: 90 nop
1057fc: 90 nop
1057fd: 90 nop
1057fe: 90 nop
1057ff: 90 nop
00105800 <rtems_configuration_get_maximum_periods>:
105800: 0f b7 05 d2 75 12 00 movzwl 0x1275d2,%eax
if ( _Objects_Is_auto_extend( info ) ) {
105807: 85 c0 test %eax,%eax
105809: 75 15 jne 105820 <rtems_configuration_get_maximum_periods+0x20><== NEVER TAKEN
10580b: 0f b7 05 c0 75 12 00 movzwl 0x1275c0,%eax
uint32_t rtems_configuration_get_maximum_periods( void )
{
return get_config_max( &_Rate_monotonic_Information );
}
105812: c3 ret
105813: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10581a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
105820: 0d 00 00 00 80 or $0x80000000,%eax <== NOT EXECUTED
105825: c3 ret <== NOT EXECUTED
105826: 90 nop
105827: 90 nop
105828: 90 nop
105829: 90 nop
10582a: 90 nop
10582b: 90 nop
10582c: 90 nop
10582d: 90 nop
10582e: 90 nop
10582f: 90 nop
00105830 <rtems_configuration_get_maximum_ports>:
105830: 0f b7 05 12 75 12 00 movzwl 0x127512,%eax
if ( _Objects_Is_auto_extend( info ) ) {
105837: 85 c0 test %eax,%eax
105839: 75 15 jne 105850 <rtems_configuration_get_maximum_ports+0x20><== NEVER TAKEN
10583b: 0f b7 05 00 75 12 00 movzwl 0x127500,%eax
uint32_t rtems_configuration_get_maximum_ports( void )
{
return get_config_max( &_Dual_ported_memory_Information );
}
105842: c3 ret
105843: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10584a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
105850: 0d 00 00 00 80 or $0x80000000,%eax <== NOT EXECUTED
105855: c3 ret <== NOT EXECUTED
105856: 90 nop
105857: 90 nop
105858: 90 nop
105859: 90 nop
10585a: 90 nop
10585b: 90 nop
10585c: 90 nop
10585d: 90 nop
10585e: 90 nop
10585f: 90 nop
00105860 <rtems_configuration_get_maximum_regions>:
105860: 0f b7 05 12 76 12 00 movzwl 0x127612,%eax
if ( _Objects_Is_auto_extend( info ) ) {
105867: 85 c0 test %eax,%eax
105869: 75 15 jne 105880 <rtems_configuration_get_maximum_regions+0x20><== NEVER TAKEN
10586b: 0f b7 05 00 76 12 00 movzwl 0x127600,%eax
uint32_t rtems_configuration_get_maximum_regions( void )
{
return get_config_max( &_Region_Information );
}
105872: c3 ret
105873: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10587a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
105880: 0d 00 00 00 80 or $0x80000000,%eax <== NOT EXECUTED
105885: c3 ret <== NOT EXECUTED
105886: 90 nop
105887: 90 nop
105888: 90 nop
105889: 90 nop
10588a: 90 nop
10588b: 90 nop
10588c: 90 nop
10588d: 90 nop
10588e: 90 nop
10588f: 90 nop
00105890 <rtems_configuration_get_maximum_semaphores>:
105890: 0f b7 05 92 76 12 00 movzwl 0x127692,%eax
if ( _Objects_Is_auto_extend( info ) ) {
105897: 85 c0 test %eax,%eax
105899: 75 15 jne 1058b0 <rtems_configuration_get_maximum_semaphores+0x20><== NEVER TAKEN
10589b: 0f b7 05 80 76 12 00 movzwl 0x127680,%eax
uint32_t rtems_configuration_get_maximum_semaphores( void )
{
return get_config_max( &_Semaphore_Information );
}
1058a2: c3 ret
1058a3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1058aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
1058b0: 0d 00 00 00 80 or $0x80000000,%eax <== NOT EXECUTED
1058b5: c3 ret <== NOT EXECUTED
1058b6: 90 nop
1058b7: 90 nop
1058b8: 90 nop
1058b9: 90 nop
1058ba: 90 nop
1058bb: 90 nop
1058bc: 90 nop
1058bd: 90 nop
1058be: 90 nop
1058bf: 90 nop
001058f0 <rtems_configuration_get_maximum_tasks>:
1058f0: 0f b7 05 92 71 12 00 movzwl 0x127192,%eax
if ( _Objects_Is_auto_extend( info ) ) {
1058f7: 85 c0 test %eax,%eax
1058f9: 75 15 jne 105910 <rtems_configuration_get_maximum_tasks+0x20><== NEVER TAKEN
1058fb: 0f b7 05 80 71 12 00 movzwl 0x127180,%eax
uint32_t rtems_configuration_get_maximum_tasks( void )
{
return get_config_max( &_RTEMS_tasks_Information.Objects );
}
105902: c3 ret
105903: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10590a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
105910: 0d 00 00 00 80 or $0x80000000,%eax <== NOT EXECUTED
105915: c3 ret <== NOT EXECUTED
105916: 90 nop
105917: 90 nop
105918: 90 nop
105919: 90 nop
10591a: 90 nop
10591b: 90 nop
10591c: 90 nop
10591d: 90 nop
10591e: 90 nop
10591f: 90 nop
001058c0 <rtems_configuration_get_maximum_timers>:
1058c0: 0f b7 05 52 76 12 00 movzwl 0x127652,%eax
if ( _Objects_Is_auto_extend( info ) ) {
1058c7: 85 c0 test %eax,%eax
1058c9: 75 15 jne 1058e0 <rtems_configuration_get_maximum_timers+0x20><== NEVER TAKEN
1058cb: 0f b7 05 40 76 12 00 movzwl 0x127640,%eax
uint32_t rtems_configuration_get_maximum_timers( void )
{
return get_config_max( &_Timer_Information );
}
1058d2: c3 ret
1058d3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1058da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return info->objects_per_block | RTEMS_UNLIMITED_OBJECTS;
1058e0: 0d 00 00 00 80 or $0x80000000,%eax <== NOT EXECUTED
1058e5: c3 ret <== NOT EXECUTED
1058e6: 90 nop
1058e7: 90 nop
1058e8: 90 nop
1058e9: 90 nop
1058ea: 90 nop
1058eb: 90 nop
1058ec: 90 nop
1058ed: 90 nop
1058ee: 90 nop
1058ef: 90 nop
0010a550 <rtems_initialize_executive>:
RTEMS_SYSINIT_IDLE_THREADS,
RTEMS_SYSINIT_ORDER_MIDDLE
);
void rtems_initialize_executive(void)
{
10a550: 55 push %ebp
10a551: 89 e5 mov %esp,%ebp
10a553: 53 push %ebx
RTEMS_INLINE_ROUTINE uintptr_t _Linker_set_Obfuscate( const void *ptr )
{
uintptr_t addr;
addr = (uintptr_t) ptr;
RTEMS_OBFUSCATE_VARIABLE( addr );
10a554: bb e0 46 12 00 mov $0x1246e0,%ebx
10a559: 83 ec 04 sub $0x4,%esp
const rtems_sysinit_item *item;
/* Invoke the registered system initialization handlers */
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
10a55c: 81 fb 18 47 12 00 cmp $0x124718,%ebx
10a562: 74 19 je 10a57d <rtems_initialize_executive+0x2d> <== NEVER TAKEN
10a564: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10a56b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10a56f: 90 nop
( *item->handler )();
10a570: ff 13 call *(%ebx)
RTEMS_LINKER_SET_FOREACH( _Sysinit, item ) {
10a572: 83 c3 04 add $0x4,%ebx
10a575: 81 fb 18 47 12 00 cmp $0x124718,%ebx
10a57b: 75 f3 jne 10a570 <rtems_initialize_executive+0x20>
10a57d: b8 02 00 00 00 mov $0x2,%eax
10a582: a3 d4 03 13 00 mov %eax,0x1303d4
_System_state_Set( SYSTEM_STATE_UP );
_SMP_Request_start_multitasking();
_Thread_Start_multitasking();
10a587: e8 e4 18 00 00 call 10be70 <_Thread_Start_multitasking>
10a58c: 90 nop
10a58d: 90 nop
10a58e: 90 nop
10a58f: 90 nop
001069d0 <rtems_io_register_driver>:
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
1069d0: 55 push %ebp
1069d1: 89 e5 mov %esp,%ebp
1069d3: 83 ec 18 sub $0x18,%esp
1069d6: 89 5d f4 mov %ebx,-0xc(%ebp)
1069d9: 8b 5d 08 mov 0x8(%ebp),%ebx
1069dc: 89 75 f8 mov %esi,-0x8(%ebp)
1069df: 8b 75 10 mov 0x10(%ebp),%esi
1069e2: 89 7d fc mov %edi,-0x4(%ebp)
1069e5: 8b 7d 0c mov 0xc(%ebp),%edi
rtems_device_major_number major_limit = _IO_Number_of_drivers;
ISR_lock_Context lock_context;
if ( rtems_interrupt_is_in_progress() )
1069e8: e8 23 18 00 00 call 108210 <_ISR_Is_in_progress>
1069ed: 84 c0 test %al,%al
1069ef: 75 4f jne 106a40 <rtems_io_register_driver+0x70>
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
1069f1: 85 f6 test %esi,%esi
1069f3: 74 72 je 106a67 <rtems_io_register_driver+0x97>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
1069f5: a1 d0 47 12 00 mov 0x1247d0,%eax
if ( driver_table == NULL )
1069fa: 85 ff test %edi,%edi
*registered_major = major_limit;
1069fc: 89 06 mov %eax,(%esi)
if ( driver_table == NULL )
1069fe: 74 67 je 106a67 <rtems_io_register_driver+0x97>
return table->initialization_entry == NULL && table->open_entry == NULL;
106a00: 8b 07 mov (%edi),%eax
106a02: 85 c0 test %eax,%eax
106a04: 74 5a je 106a60 <rtems_io_register_driver+0x90>
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
106a06: 39 1d d0 47 12 00 cmp %ebx,0x1247d0
106a0c: 0f 86 fe 00 00 00 jbe 106b10 <rtems_io_register_driver+0x140>
RTEMS_INLINE_ROUTINE void _IO_Driver_registration_acquire(
ISR_lock_Context *lock_context
)
{
_ISR_lock_ISR_disable_and_acquire(
106a12: 9c pushf
106a13: fa cli
106a14: 59 pop %ecx
return RTEMS_INVALID_NUMBER;
_IO_Driver_registration_acquire( &lock_context );
if ( major == 0 ) {
106a15: 85 db test %ebx,%ebx
106a17: 0f 84 c3 00 00 00 je 106ae0 <rtems_io_register_driver+0x110>
_IO_Driver_registration_release( &lock_context );
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
106a1d: 8d 04 5b lea (%ebx,%ebx,2),%eax
106a20: c1 e0 03 shl $0x3,%eax
return table->initialization_entry == NULL && table->open_entry == NULL;
106a23: 8b 90 00 b7 12 00 mov 0x12b700(%eax),%edx
106a29: 85 d2 test %edx,%edx
106a2b: 74 53 je 106a80 <rtems_io_register_driver+0xb0>
RTEMS_INLINE_ROUTINE void _IO_Driver_registration_release(
ISR_lock_Context *lock_context
)
{
_ISR_lock_Release_and_ISR_enable(
106a2d: 51 push %ecx
106a2e: 9d popf
if ( !rtems_io_is_empty_table( table ) ) {
_IO_Driver_registration_release( &lock_context );
return RTEMS_RESOURCE_IN_USE;
106a2f: b8 0c 00 00 00 mov $0xc,%eax
106a34: eb 0f jmp 106a45 <rtems_io_register_driver+0x75>
106a36: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106a3d: 8d 76 00 lea 0x0(%esi),%esi
return RTEMS_CALLED_FROM_ISR;
106a40: b8 12 00 00 00 mov $0x12,%eax
/* The driver will be initialized together with all other drivers
* in a later stage by _IO_Initialize_all_drivers().
*/
return RTEMS_SUCCESSFUL;
}
}
106a45: 8b 5d f4 mov -0xc(%ebp),%ebx
106a48: 8b 75 f8 mov -0x8(%ebp),%esi
106a4b: 8b 7d fc mov -0x4(%ebp),%edi
106a4e: 89 ec mov %ebp,%esp
106a50: 5d pop %ebp
106a51: c3 ret
106a52: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106a59: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
return table->initialization_entry == NULL && table->open_entry == NULL;
106a60: 8b 47 04 mov 0x4(%edi),%eax
106a63: 85 c0 test %eax,%eax
106a65: 75 9f jne 106a06 <rtems_io_register_driver+0x36>
}
106a67: 8b 5d f4 mov -0xc(%ebp),%ebx
return RTEMS_INVALID_ADDRESS;
106a6a: b8 09 00 00 00 mov $0x9,%eax
}
106a6f: 8b 75 f8 mov -0x8(%ebp),%esi
106a72: 8b 7d fc mov -0x4(%ebp),%edi
106a75: 89 ec mov %ebp,%esp
106a77: 5d pop %ebp
106a78: c3 ret
106a79: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
return table->initialization_entry == NULL && table->open_entry == NULL;
106a80: 8b 80 04 b7 12 00 mov 0x12b704(%eax),%eax
106a86: 85 c0 test %eax,%eax
106a88: 75 a3 jne 106a2d <rtems_io_register_driver+0x5d>
106a8a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
*registered_major = major;
106a90: 89 1e mov %ebx,(%esi)
_IO_Driver_address_table [major] = *driver_table;
106a92: 8d 04 5b lea (%ebx,%ebx,2),%eax
106a95: 8d 34 c5 00 b7 12 00 lea 0x12b700(,%eax,8),%esi
106a9c: 31 c0 xor %eax,%eax
106a9e: 8b 14 07 mov (%edi,%eax,1),%edx
106aa1: 89 14 06 mov %edx,(%esi,%eax,1)
106aa4: 83 c0 04 add $0x4,%eax
106aa7: 83 f8 18 cmp $0x18,%eax
106aaa: 72 f2 jb 106a9e <rtems_io_register_driver+0xce>
106aac: 51 push %ecx
106aad: 9d popf
return RTEMS_SUCCESSFUL;
106aae: 31 c0 xor %eax,%eax
if ( _IO_All_drivers_initialized ) {
106ab0: 80 3d 44 cf 12 00 00 cmpb $0x0,0x12cf44
106ab7: 74 8c je 106a45 <rtems_io_register_driver+0x75> <== NEVER TAKEN
return rtems_io_initialize( major, 0, NULL );
106ab9: 89 5d 08 mov %ebx,0x8(%ebp)
}
106abc: 8b 75 f8 mov -0x8(%ebp),%esi
return rtems_io_initialize( major, 0, NULL );
106abf: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp)
}
106ac6: 8b 5d f4 mov -0xc(%ebp),%ebx
return rtems_io_initialize( major, 0, NULL );
106ac9: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp)
}
106ad0: 8b 7d fc mov -0x4(%ebp),%edi
106ad3: 89 ec mov %ebp,%esp
106ad5: 5d pop %ebp
return rtems_io_initialize( major, 0, NULL );
106ad6: e9 a5 fe ff ff jmp 106980 <rtems_io_initialize>
106adb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
106adf: 90 nop
for ( m = 0; m < n; ++m ) {
106ae0: a1 d0 47 12 00 mov 0x1247d0,%eax
106ae5: 85 c0 test %eax,%eax
106ae7: 74 5a je 106b43 <rtems_io_register_driver+0x173> <== NEVER TAKEN
106ae9: b8 00 b7 12 00 mov $0x12b700,%eax
106aee: eb 0c jmp 106afc <rtems_io_register_driver+0x12c>
106af0: 43 inc %ebx
106af1: 83 c0 18 add $0x18,%eax
106af4: 39 1d d0 47 12 00 cmp %ebx,0x1247d0
106afa: 74 34 je 106b30 <rtems_io_register_driver+0x160>
return table->initialization_entry == NULL && table->open_entry == NULL;
106afc: 8b 10 mov (%eax),%edx
106afe: 85 d2 test %edx,%edx
106b00: 75 ee jne 106af0 <rtems_io_register_driver+0x120>
106b02: 8b 50 04 mov 0x4(%eax),%edx
106b05: 85 d2 test %edx,%edx
106b07: 75 e7 jne 106af0 <rtems_io_register_driver+0x120>
106b09: eb 85 jmp 106a90 <rtems_io_register_driver+0xc0>
106b0b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
106b0f: 90 nop
}
106b10: 8b 5d f4 mov -0xc(%ebp),%ebx
return RTEMS_INVALID_NUMBER;
106b13: b8 0a 00 00 00 mov $0xa,%eax
}
106b18: 8b 75 f8 mov -0x8(%ebp),%esi
106b1b: 8b 7d fc mov -0x4(%ebp),%edi
106b1e: 89 ec mov %ebp,%esp
106b20: 5d pop %ebp
106b21: c3 ret
106b22: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106b29: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
*major = m;
106b30: a1 d0 47 12 00 mov 0x1247d0,%eax
106b35: 89 06 mov %eax,(%esi)
106b37: 51 push %ecx
106b38: 9d popf
return RTEMS_TOO_MANY;
106b39: b8 05 00 00 00 mov $0x5,%eax
return sc;
106b3e: e9 02 ff ff ff jmp 106a45 <rtems_io_register_driver+0x75>
*major = m;
106b43: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED
if ( m != n )
106b49: eb ec jmp 106b37 <rtems_io_register_driver+0x167> <== NOT EXECUTED
106b4b: 90 nop
106b4c: 90 nop
106b4d: 90 nop
106b4e: 90 nop
106b4f: 90 nop
001046f0 <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
1046f0: 55 push %ebp
uintptr_t excess = value % alignment;
1046f1: 31 d2 xor %edx,%edx
{
1046f3: 89 e5 mov %esp,%ebp
1046f5: 57 push %edi
1046f6: 56 push %esi
1046f7: 53 push %ebx
1046f8: 83 ec 2c sub $0x2c,%esp
1046fb: 8b 7d 08 mov 0x8(%ebp),%edi
1046fe: 8b 4d 0c mov 0xc(%ebp),%ecx
void *ptr = NULL;
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
104701: 8b 77 1c mov 0x1c(%edi),%esi
uintptr_t excess = value % alignment;
104704: 89 c8 mov %ecx,%eax
104706: f7 f6 div %esi
if (excess > 0) {
104708: 85 d2 test %edx,%edx
10470a: 74 74 je 104780 <rtems_rbheap_allocate+0x90>
value += alignment - excess;
10470c: 01 ce add %ecx,%esi
10470e: 29 d6 sub %edx,%esi
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
104710: 39 f1 cmp %esi,%ecx
104712: 0f 96 c0 setbe %al
104715: 85 c9 test %ecx,%ecx
104717: 74 57 je 104770 <rtems_rbheap_allocate+0x80>
104719: 84 c0 test %al,%al
10471b: 74 53 je 104770 <rtems_rbheap_allocate+0x80> <== NEVER TAKEN
return _Chain_Immutable_head( the_chain )->next;
10471d: 8b 1f mov (%edi),%ebx
return &the_chain->Tail.Node;
10471f: 8d 47 04 lea 0x4(%edi),%eax
while (current != tail && big_enough == NULL) {
104722: 39 c3 cmp %eax,%ebx
104724: 74 4a je 104770 <rtems_rbheap_allocate+0x80>
104726: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10472d: 8d 76 00 lea 0x0(%esi),%esi
if (free_chunk->size >= size) {
104730: 3b 73 1c cmp 0x1c(%ebx),%esi
104733: 77 2b ja 104760 <rtems_rbheap_allocate+0x70>
rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size);
if (free_chunk != NULL) {
uintptr_t free_size = free_chunk->size;
104735: 8b 43 1c mov 0x1c(%ebx),%eax
104738: 89 45 e4 mov %eax,-0x1c(%ebp)
if (free_size > aligned_size) {
10473b: 39 f0 cmp %esi,%eax
10473d: 77 51 ja 104790 <rtems_rbheap_allocate+0xa0>
next = the_node->next;
10473f: 8b 13 mov (%ebx),%edx
previous = the_node->previous;
104741: 8b 43 04 mov 0x4(%ebx),%eax
next->previous = previous;
104744: 89 42 04 mov %eax,0x4(%edx)
previous->next = next;
104747: 89 10 mov %edx,(%eax)
ptr = (void *) new_chunk->begin;
}
} else {
rtems_chain_extract_unprotected(&free_chunk->chain_node);
rtems_chain_set_off_chain(&free_chunk->chain_node);
ptr = (void *) free_chunk->begin;
104749: 8b 43 18 mov 0x18(%ebx),%eax
node->next = NULL;
10474c: c7 03 00 00 00 00 movl $0x0,(%ebx)
}
}
}
return ptr;
}
104752: 83 c4 2c add $0x2c,%esp
104755: 5b pop %ebx
104756: 5e pop %esi
104757: 5f pop %edi
104758: 5d pop %ebp
104759: c3 ret
10475a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return the_node->next;
104760: 8b 1b mov (%ebx),%ebx
while (current != tail && big_enough == NULL) {
104762: 39 d8 cmp %ebx,%eax
104764: 75 ca jne 104730 <rtems_rbheap_allocate+0x40> <== NEVER TAKEN
104766: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10476d: 8d 76 00 lea 0x0(%esi),%esi
void *ptr = NULL;
104770: 31 c0 xor %eax,%eax
}
104772: 83 c4 2c add $0x2c,%esp
104775: 5b pop %ebx
104776: 5e pop %esi
104777: 5f pop %edi
104778: 5d pop %ebp
104779: c3 ret
10477a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
104780: 89 ce mov %ecx,%esi
104782: b0 01 mov $0x1,%al
104784: eb 8f jmp 104715 <rtems_rbheap_allocate+0x25>
104786: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10478d: 8d 76 00 lea 0x0(%esi),%esi
return _Chain_Immutable_head( the_chain )->next;
104790: 8b 57 0c mov 0xc(%edi),%edx
return &the_chain->Tail.Node;
104793: 8d 4f 0c lea 0xc(%edi),%ecx
104796: 89 4d e0 mov %ecx,-0x20(%ebp)
104799: 8d 4f 10 lea 0x10(%edi),%ecx
if ( !_Chain_Is_empty(the_chain))
10479c: 39 ca cmp %ecx,%edx
10479e: 74 59 je 1047f9 <rtems_rbheap_allocate+0x109>
new_first = old_first->next;
1047a0: 8b 0a mov (%edx),%ecx
return &the_chain->Head.Node;
1047a2: 8d 47 0c lea 0xc(%edi),%eax
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
1047a5: 83 c7 18 add $0x18,%edi
head->next = new_first;
1047a8: 89 4f f4 mov %ecx,-0xc(%edi)
return &the_chain->Head.Node;
1047ab: 89 41 04 mov %eax,0x4(%ecx)
uintptr_t new_free_size = free_size - aligned_size;
1047ae: 8b 45 e4 mov -0x1c(%ebp),%eax
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
1047b1: 89 55 e4 mov %edx,-0x1c(%ebp)
new_chunk->begin = free_chunk->begin + new_free_size;
1047b4: 8b 4b 18 mov 0x18(%ebx),%ecx
uintptr_t new_free_size = free_size - aligned_size;
1047b7: 29 f0 sub %esi,%eax
free_chunk->size = new_free_size;
1047b9: 89 43 1c mov %eax,0x1c(%ebx)
new_chunk->begin = free_chunk->begin + new_free_size;
1047bc: 01 c8 add %ecx,%eax
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
1047be: bb 01 00 00 00 mov $0x1,%ebx
new_chunk->begin = free_chunk->begin + new_free_size;
1047c3: 89 42 18 mov %eax,0x18(%edx)
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
1047c6: 8d 42 08 lea 0x8(%edx),%eax
new_chunk->size = aligned_size;
1047c9: 89 72 1c mov %esi,0x1c(%edx)
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
1047cc: be a0 45 10 00 mov $0x1045a0,%esi
node->next = NULL;
1047d1: c7 02 00 00 00 00 movl $0x0,(%edx)
1047d7: 89 5c 24 0c mov %ebx,0xc(%esp)
1047db: 89 74 24 08 mov %esi,0x8(%esp)
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
1047df: 89 3c 24 mov %edi,(%esp)
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
1047e2: 89 44 24 04 mov %eax,0x4(%esp)
1047e6: e8 65 02 00 00 call 104a50 <rtems_rbtree_insert>
ptr = (void *) new_chunk->begin;
1047eb: 8b 55 e4 mov -0x1c(%ebp),%edx
1047ee: 8b 42 18 mov 0x18(%edx),%eax
}
1047f1: 83 c4 2c add $0x2c,%esp
1047f4: 5b pop %ebx
1047f5: 5e pop %esi
1047f6: 5f pop %edi
1047f7: 5d pop %ebp
1047f8: c3 ret
(*control->extend_descriptors)(control);
1047f9: 89 3c 24 mov %edi,(%esp)
1047fc: 89 4d e0 mov %ecx,-0x20(%ebp)
1047ff: ff 57 20 call *0x20(%edi)
return _Chain_Immutable_head( the_chain )->next;
104802: 8b 57 0c mov 0xc(%edi),%edx
if ( !_Chain_Is_empty(the_chain))
104805: 8b 4d e0 mov -0x20(%ebp),%ecx
104808: 39 d1 cmp %edx,%ecx
10480a: 75 94 jne 1047a0 <rtems_rbheap_allocate+0xb0>
void *ptr = NULL;
10480c: 31 c0 xor %eax,%eax
10480e: e9 5f ff ff ff jmp 104772 <rtems_rbheap_allocate+0x82>
104813: 90 nop
104814: 90 nop
104815: 90 nop
104816: 90 nop
104817: 90 nop
104818: 90 nop
104819: 90 nop
10481a: 90 nop
10481b: 90 nop
10481c: 90 nop
10481d: 90 nop
10481e: 90 nop
10481f: 90 nop
00104820 <rtems_rbheap_free>:
rtems_rbtree_extract(&control->chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
104820: 55 push %ebp
104821: 89 e5 mov %esp,%ebp
104823: 83 ec 58 sub $0x58,%esp
104826: 89 5d f4 mov %ebx,-0xc(%ebp)
104829: 8b 4d 0c mov 0xc(%ebp),%ecx
10482c: 89 75 f8 mov %esi,-0x8(%ebp)
10482f: 89 7d fc mov %edi,-0x4(%ebp)
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
104832: 85 c9 test %ecx,%ecx
104834: 0f 84 26 01 00 00 je 104960 <rtems_rbheap_free+0x140>
rtems_rbheap_chunk *chunk = find(&control->chunk_tree, (uintptr_t) ptr);
10483a: 8b 45 08 mov 0x8(%ebp),%eax
rtems_rbheap_chunk chunk = { .begin = key };
10483d: 31 d2 xor %edx,%edx
rtems_rbheap_chunk *chunk = find(&control->chunk_tree, (uintptr_t) ptr);
10483f: 8d 78 18 lea 0x18(%eax),%edi
rtems_rbheap_chunk chunk = { .begin = key };
104842: 31 c0 xor %eax,%eax
104844: 89 54 05 c8 mov %edx,-0x38(%ebp,%eax,1)
104848: 89 54 05 cc mov %edx,-0x34(%ebp,%eax,1)
10484c: 83 c0 08 add $0x8,%eax
10484f: 83 f8 20 cmp $0x20,%eax
104852: 72 f0 jb 104844 <rtems_rbheap_free+0x24>
104854: 89 4d e0 mov %ecx,-0x20(%ebp)
return rtems_rbheap_chunk_of_node(
104857: bb a0 45 10 00 mov $0x1045a0,%ebx
10485c: b9 01 00 00 00 mov $0x1,%ecx
104861: 89 5c 24 08 mov %ebx,0x8(%esp)
104865: 8d 45 d0 lea -0x30(%ebp),%eax
104868: 89 4c 24 0c mov %ecx,0xc(%esp)
10486c: 89 44 24 04 mov %eax,0x4(%esp)
104870: 89 3c 24 mov %edi,(%esp)
104873: e8 68 01 00 00 call 1049e0 <rtems_rbtree_find>
if (chunk != NULL_PAGE) {
104878: 85 c0 test %eax,%eax
return rtems_rbheap_chunk_of_node(
10487a: 89 c3 mov %eax,%ebx
10487c: 8d 70 f8 lea -0x8(%eax),%esi
if (chunk != NULL_PAGE) {
10487f: 0f 84 eb 00 00 00 je 104970 <rtems_rbheap_free+0x150>
if (!rtems_rbheap_is_chunk_free(chunk)) {
104885: 8b 53 f8 mov -0x8(%ebx),%edx
other = succ(chunk);
check_and_merge(control, chunk, other, other);
other = pred(chunk);
check_and_merge(control, other, chunk, other);
} else {
sc = RTEMS_INCORRECT_STATE;
104888: b8 0e 00 00 00 mov $0xe,%eax
if (!rtems_rbheap_is_chunk_free(chunk)) {
10488d: 85 d2 test %edx,%edx
10488f: 0f 85 cd 00 00 00 jne 104962 <rtems_rbheap_free+0x142>
the_node->previous = after_node;
104895: 8b 45 08 mov 0x8(%ebp),%eax
after_node->next = the_node;
104898: 8b 55 08 mov 0x8(%ebp),%edx
the_node->previous = after_node;
10489b: 89 46 04 mov %eax,0x4(%esi)
before_node = after_node->next;
10489e: 8b 00 mov (%eax),%eax
after_node->next = the_node;
1048a0: 89 32 mov %esi,(%edx)
the_node->next = before_node;
1048a2: 89 43 f8 mov %eax,-0x8(%ebx)
before_node->previous = the_node;
1048a5: 89 70 04 mov %esi,0x4(%eax)
*/
RTEMS_INLINE_ROUTINE rtems_rbtree_node* rtems_rbtree_successor(
const rtems_rbtree_node *node
)
{
return _RBTree_Successor( node );
1048a8: 89 1c 24 mov %ebx,(%esp)
1048ab: e8 b0 1f 00 00 call 106860 <_RBTree_Successor>
if (c != NULL_PAGE && rtems_rbheap_is_chunk_free(c)) {
1048b0: 85 c0 test %eax,%eax
1048b2: 74 50 je 104904 <rtems_rbheap_free+0xe4>
return node->next == NULL;
1048b4: 8b 48 f8 mov -0x8(%eax),%ecx
return rtems_rbheap_chunk_of_node(
1048b7: 8d 50 f8 lea -0x8(%eax),%edx
1048ba: 89 55 c4 mov %edx,-0x3c(%ebp)
if (c != NULL_PAGE && rtems_rbheap_is_chunk_free(c)) {
1048bd: 85 c9 test %ecx,%ecx
1048bf: 74 43 je 104904 <rtems_rbheap_free+0xe4>
a->size += b->size;
1048c1: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED
1048c4: 01 56 1c add %edx,0x1c(%esi) <== NOT EXECUTED
previous = the_node->previous;
1048c7: 8b 50 fc mov -0x4(%eax),%edx <== NOT EXECUTED
next->previous = previous;
1048ca: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED
previous->next = next;
1048cd: 89 0a mov %ecx,(%edx) <== NOT EXECUTED
return &the_chain->Head.Node;
1048cf: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
1048d2: 8d 48 f8 lea -0x8(%eax),%ecx <== NOT EXECUTED
1048d5: 83 c2 0c add $0xc,%edx <== NOT EXECUTED
1048d8: 89 50 fc mov %edx,-0x4(%eax) <== NOT EXECUTED
before_node = after_node->next;
1048db: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
1048de: 8b 52 0c mov 0xc(%edx),%edx <== NOT EXECUTED
1048e1: 89 55 c4 mov %edx,-0x3c(%ebp) <== NOT EXECUTED
after_node->next = the_node;
1048e4: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
1048e7: 89 4a 0c mov %ecx,0xc(%edx) <== NOT EXECUTED
the_node->next = before_node;
1048ea: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED
1048ed: 89 48 f8 mov %ecx,-0x8(%eax) <== NOT EXECUTED
1048f0: 89 ca mov %ecx,%edx <== NOT EXECUTED
before_node->previous = the_node;
1048f2: 8d 48 f8 lea -0x8(%eax),%ecx <== NOT EXECUTED
1048f5: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED
rtems_rbtree_extract(&control->chunk_tree, &b->tree_node);
1048f8: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_rbtree_extract(
rtems_rbtree_control *the_rbtree,
rtems_rbtree_node *the_node
)
{
_RBTree_Extract( the_rbtree, the_node );
1048fc: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
1048ff: e8 3c 18 00 00 call 106140 <_RBTree_Extract> <== NOT EXECUTED
return _RBTree_Predecessor( node );
104904: 89 1c 24 mov %ebx,(%esp)
104907: e8 a4 1f 00 00 call 1068b0 <_RBTree_Predecessor>
if (c != NULL_PAGE && rtems_rbheap_is_chunk_free(c)) {
10490c: 85 c0 test %eax,%eax
10490e: 74 50 je 104960 <rtems_rbheap_free+0x140>
return rtems_rbheap_chunk_of_node(
104910: 8d 50 f8 lea -0x8(%eax),%edx
if (c != NULL_PAGE && rtems_rbheap_is_chunk_free(c)) {
104913: 8b 40 f8 mov -0x8(%eax),%eax
104916: 85 c0 test %eax,%eax
104918: 74 46 je 104960 <rtems_rbheap_free+0x140>
a->size += b->size;
10491a: 8b 46 1c mov 0x1c(%esi),%eax
10491d: 01 42 1c add %eax,0x1c(%edx)
next = the_node->next;
104920: 8b 53 f8 mov -0x8(%ebx),%edx
previous = the_node->previous;
104923: 8b 46 04 mov 0x4(%esi),%eax
next->previous = previous;
104926: 89 42 04 mov %eax,0x4(%edx)
previous->next = next;
104929: 89 10 mov %edx,(%eax)
return &the_chain->Head.Node;
10492b: 8b 45 08 mov 0x8(%ebp),%eax
after_node->next = the_node;
10492e: 8b 55 08 mov 0x8(%ebp),%edx
return &the_chain->Head.Node;
104931: 83 c0 0c add $0xc,%eax
104934: 89 46 04 mov %eax,0x4(%esi)
before_node = after_node->next;
104937: 8b 45 08 mov 0x8(%ebp),%eax
10493a: 8b 40 0c mov 0xc(%eax),%eax
after_node->next = the_node;
10493d: 89 72 0c mov %esi,0xc(%edx)
the_node->next = before_node;
104940: 89 43 f8 mov %eax,-0x8(%ebx)
before_node->previous = the_node;
104943: 89 70 04 mov %esi,0x4(%eax)
_RBTree_Extract( the_rbtree, the_node );
104946: 89 5c 24 04 mov %ebx,0x4(%esp)
10494a: 89 3c 24 mov %edi,(%esp)
10494d: e8 ee 17 00 00 call 106140 <_RBTree_Extract>
104952: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104959: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
rtems_status_code sc = RTEMS_SUCCESSFUL;
104960: 31 c0 xor %eax,%eax
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
104962: 8b 5d f4 mov -0xc(%ebp),%ebx
104965: 8b 75 f8 mov -0x8(%ebp),%esi
104968: 8b 7d fc mov -0x4(%ebp),%edi
10496b: 89 ec mov %ebp,%esp
10496d: 5d pop %ebp
10496e: c3 ret
10496f: 90 nop
104970: 8b 5d f4 mov -0xc(%ebp),%ebx
sc = RTEMS_INVALID_ID;
104973: b8 04 00 00 00 mov $0x4,%eax
}
104978: 8b 75 f8 mov -0x8(%ebp),%esi
10497b: 8b 7d fc mov -0x4(%ebp),%edi
10497e: 89 ec mov %ebp,%esp
104980: 5d pop %ebp
104981: c3 ret
104982: 90 nop
104983: 90 nop
104984: 90 nop
104985: 90 nop
104986: 90 nop
104987: 90 nop
104988: 90 nop
104989: 90 nop
10498a: 90 nop
10498b: 90 nop
10498c: 90 nop
10498d: 90 nop
10498e: 90 nop
10498f: 90 nop
001045c0 <rtems_rbheap_initialize>:
uintptr_t area_size,
uintptr_t alignment,
rtems_rbheap_extend_descriptors extend_descriptors,
void *handler_arg
)
{
1045c0: 55 push %ebp
1045c1: 89 e5 mov %esp,%ebp
1045c3: 83 ec 38 sub $0x38,%esp
1045c6: 89 75 f8 mov %esi,-0x8(%ebp)
/*
* Ensure that the alignment is at least two, so that we can keep
* chunk_compare() that simple.
*/
alignment = alignment < 2 ? 2 : alignment;
1045c9: 8b 4d 14 mov 0x14(%ebp),%ecx
{
1045cc: 89 7d fc mov %edi,-0x4(%ebp)
1045cf: 8b 75 0c mov 0xc(%ebp),%esi
1045d2: 89 5d f4 mov %ebx,-0xc(%ebp)
uintptr_t end = begin + area_size;
1045d5: 8b 7d 10 mov 0x10(%ebp),%edi
{
1045d8: 8b 5d 08 mov 0x8(%ebp),%ebx
uintptr_t end = begin + area_size;
1045db: 01 f7 add %esi,%edi
alignment = alignment < 2 ? 2 : alignment;
1045dd: 83 f9 02 cmp $0x2,%ecx
1045e0: 73 05 jae 1045e7 <rtems_rbheap_initialize+0x27> <== ALWAYS TAKEN
1045e2: b9 02 00 00 00 mov $0x2,%ecx <== NOT EXECUTED
uintptr_t excess = value % alignment;
1045e7: 31 d2 xor %edx,%edx
1045e9: 89 f0 mov %esi,%eax
1045eb: f7 f1 div %ecx
if (excess > 0) {
1045ed: 85 d2 test %edx,%edx
1045ef: 74 3f je 104630 <rtems_rbheap_initialize+0x70>
value += alignment - excess;
1045f1: 8d 04 0e lea (%esi,%ecx,1),%eax
1045f4: 29 d0 sub %edx,%eax
1045f6: 89 45 e0 mov %eax,-0x20(%ebp)
aligned_begin = align_up(alignment, begin);
aligned_end = align_down(alignment, end);
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
1045f9: 39 c6 cmp %eax,%esi
1045fb: 0f 96 45 e4 setbe -0x1c(%ebp)
uintptr_t excess = value % alignment;
1045ff: 31 d2 xor %edx,%edx
104601: 89 f8 mov %edi,%eax
104603: f7 f1 div %ecx
return value - excess;
104605: 89 f8 mov %edi,%eax
104607: 29 d0 sub %edx,%eax
if (begin < end && begin <= aligned_begin && aligned_begin < aligned_end) {
104609: 39 fe cmp %edi,%esi
10460b: 0f 92 c2 setb %dl
10460e: 84 55 e4 test %dl,-0x1c(%ebp)
104611: 74 08 je 10461b <rtems_rbheap_initialize+0x5b>
104613: 3b 45 e0 cmp -0x20(%ebp),%eax
104616: 89 45 e4 mov %eax,-0x1c(%ebp)
104619: 77 25 ja 104640 <rtems_rbheap_initialize+0x80>
insert_into_tree(chunk_tree, first);
} else {
sc = RTEMS_NO_MEMORY;
}
} else {
sc = RTEMS_INVALID_ADDRESS;
10461b: b8 09 00 00 00 mov $0x9,%eax
}
return sc;
}
104620: 8b 5d f4 mov -0xc(%ebp),%ebx
104623: 8b 75 f8 mov -0x8(%ebp),%esi
104626: 8b 7d fc mov -0x4(%ebp),%edi
104629: 89 ec mov %ebp,%esp
10462b: 5d pop %ebp
10462c: c3 ret
10462d: 8d 76 00 lea 0x0(%esi),%esi
104630: 89 75 e0 mov %esi,-0x20(%ebp)
104633: c6 45 e4 01 movb $0x1,-0x1c(%ebp)
104637: eb c6 jmp 1045ff <rtems_rbheap_initialize+0x3f>
104639: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
104640: 8d 43 18 lea 0x18(%ebx),%eax
104643: 89 45 dc mov %eax,-0x24(%ebp)
return &the_chain->Tail.Node;
104646: 8d 53 04 lea 0x4(%ebx),%edx
control->extend_descriptors = extend_descriptors;
104649: 8b 45 18 mov 0x18(%ebp),%eax
10464c: 89 13 mov %edx,(%ebx)
control->handler_arg = handler_arg;
10464e: 8b 55 1c mov 0x1c(%ebp),%edx
104651: 8d 73 10 lea 0x10(%ebx),%esi
head->previous = NULL;
104654: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
return &the_chain->Head.Node;
10465b: 8d 7b 0c lea 0xc(%ebx),%edi
tail->previous = head;
10465e: 89 5b 08 mov %ebx,0x8(%ebx)
head->next = tail;
104661: 89 73 0c mov %esi,0xc(%ebx)
104664: 89 53 24 mov %edx,0x24(%ebx)
head->previous = NULL;
104667: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
tail->previous = head;
10466e: 89 7b 14 mov %edi,0x14(%ebx)
*/
RTEMS_INLINE_ROUTINE void _RBTree_Initialize_empty(
RBTree_Control *the_rbtree
)
{
RB_INIT( the_rbtree );
104671: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
control->alignment = alignment;
104678: 89 4b 1c mov %ecx,0x1c(%ebx)
control->extend_descriptors = extend_descriptors;
10467b: 89 43 20 mov %eax,0x20(%ebx)
(*control->extend_descriptors)(control);
10467e: 89 1c 24 mov %ebx,(%esp)
104681: ff 55 18 call *0x18(%ebp)
return _Chain_Immutable_head( the_chain )->next;
104684: 8b 53 0c mov 0xc(%ebx),%edx
if ( !_Chain_Is_empty(the_chain))
104687: 39 d6 cmp %edx,%esi
104689: 74 55 je 1046e0 <rtems_rbheap_initialize+0x120>
new_first = old_first->next;
10468b: 8b 0a mov (%edx),%ecx
first->size = aligned_end - aligned_begin;
10468d: 8b 45 e4 mov -0x1c(%ebp),%eax
head->next = new_first;
104690: 89 4b 0c mov %ecx,0xc(%ebx)
new_first->previous = head;
104693: 89 79 04 mov %edi,0x4(%ecx)
first->begin = aligned_begin;
104696: 8b 4d e0 mov -0x20(%ebp),%ecx
the_node->previous = after_node;
104699: 89 5a 04 mov %ebx,0x4(%edx)
10469c: 89 4a 18 mov %ecx,0x18(%edx)
first->size = aligned_end - aligned_begin;
10469f: 29 c8 sub %ecx,%eax
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
1046a1: b9 a0 45 10 00 mov $0x1045a0,%ecx
first->size = aligned_end - aligned_begin;
1046a6: 89 42 1c mov %eax,0x1c(%edx)
before_node = after_node->next;
1046a9: 8b 03 mov (%ebx),%eax
after_node->next = the_node;
1046ab: 89 13 mov %edx,(%ebx)
the_node->next = before_node;
1046ad: 89 02 mov %eax,(%edx)
before_node->previous = the_node;
1046af: 89 50 04 mov %edx,0x4(%eax)
rtems_rbtree_insert(tree, &chunk->tree_node, chunk_compare, true);
1046b2: b8 01 00 00 00 mov $0x1,%eax
1046b7: 83 c2 08 add $0x8,%edx
1046ba: 89 44 24 0c mov %eax,0xc(%esp)
1046be: 8b 45 dc mov -0x24(%ebp),%eax
1046c1: 89 4c 24 08 mov %ecx,0x8(%esp)
1046c5: 89 54 24 04 mov %edx,0x4(%esp)
1046c9: 89 04 24 mov %eax,(%esp)
1046cc: e8 7f 03 00 00 call 104a50 <rtems_rbtree_insert>
}
1046d1: 8b 5d f4 mov -0xc(%ebp),%ebx
rtems_status_code sc = RTEMS_SUCCESSFUL;
1046d4: 31 c0 xor %eax,%eax
}
1046d6: 8b 75 f8 mov -0x8(%ebp),%esi
1046d9: 8b 7d fc mov -0x4(%ebp),%edi
1046dc: 89 ec mov %ebp,%esp
1046de: 5d pop %ebp
1046df: c3 ret
sc = RTEMS_NO_MEMORY;
1046e0: b8 1a 00 00 00 mov $0x1a,%eax
return sc;
1046e5: e9 36 ff ff ff jmp 104620 <rtems_rbheap_initialize+0x60>
1046ea: 90 nop
1046eb: 90 nop
1046ec: 90 nop
1046ed: 90 nop
1046ee: 90 nop
1046ef: 90 nop
001057c0 <rtems_rbtree_initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
1057c0: 55 push %ebp
1057c1: 89 e5 mov %esp,%ebp
1057c3: 57 push %edi
1057c4: 56 push %esi
1057c5: 53 push %ebx
1057c6: 83 ec 1c sub $0x1c,%esp
1057c9: 8b 45 14 mov 0x14(%ebp),%eax
1057cc: 8b 55 08 mov 0x8(%ebp),%edx
count = number_nodes;
next = starting_address;
while ( count-- ) {
rtems_rbtree_insert( the_rbtree, next, compare, is_unique );
1057cf: 0f b6 75 1c movzbl 0x1c(%ebp),%esi
while ( count-- ) {
1057d3: 85 c0 test %eax,%eax
1057d5: c7 02 00 00 00 00 movl $0x0,(%edx)
1057db: 74 37 je 105814 <rtems_rbtree_initialize+0x54> <== NEVER TAKEN
1057dd: 8d 78 ff lea -0x1(%eax),%edi
1057e0: 89 fb mov %edi,%ebx
1057e2: 8b 7d 10 mov 0x10(%ebp),%edi
1057e5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1057ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
rtems_rbtree_insert( the_rbtree, next, compare, is_unique );
1057f0: 89 7c 24 04 mov %edi,0x4(%esp)
1057f4: 8b 45 0c mov 0xc(%ebp),%eax
1057f7: 89 74 24 0c mov %esi,0xc(%esp)
1057fb: 89 44 24 08 mov %eax,0x8(%esp)
1057ff: 8b 45 08 mov 0x8(%ebp),%eax
105802: 89 04 24 mov %eax,(%esp)
105805: e8 86 00 00 00 call 105890 <rtems_rbtree_insert>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
10580a: 8b 45 18 mov 0x18(%ebp),%eax
10580d: 01 c7 add %eax,%edi
while ( count-- ) {
10580f: 83 eb 01 sub $0x1,%ebx
105812: 73 dc jae 1057f0 <rtems_rbtree_initialize+0x30>
next = (rtems_rbtree_node *) _Addresses_Add_offset( next, node_size );
}
}
105814: 83 c4 1c add $0x1c,%esp
105817: 5b pop %ebx
105818: 5e pop %esi
105819: 5f pop %edi
10581a: 5d pop %ebp
10581b: c3 ret
10581c: 90 nop
10581d: 90 nop
10581e: 90 nop
10581f: 90 nop
00104a50 <rtems_rbtree_insert>:
rtems_rbtree_control *the_rbtree,
rtems_rbtree_node *the_node,
rtems_rbtree_compare compare,
bool is_unique
)
{
104a50: 55 push %ebp
104a51: 89 e5 mov %esp,%ebp
104a53: 57 push %edi
104a54: 56 push %esi
104a55: 53 push %ebx
104a56: 83 ec 2c sub $0x2c,%esp
104a59: 0f b6 45 14 movzbl 0x14(%ebp),%eax
104a5d: 8b 75 0c mov 0xc(%ebp),%esi
104a60: 8b 7d 10 mov 0x10(%ebp),%edi
104a63: 88 45 e7 mov %al,-0x19(%ebp)
rtems_rbtree_node **which = _RBTree_Root_reference( the_rbtree );
rtems_rbtree_node *parent = NULL;
while ( *which != NULL ) {
104a66: 8b 45 08 mov 0x8(%ebp),%eax
104a69: 8b 18 mov (%eax),%ebx
104a6b: 85 db test %ebx,%ebx
104a6d: 75 13 jne 104a82 <rtems_rbtree_insert+0x32>
104a6f: eb 67 jmp 104ad8 <rtems_rbtree_insert+0x88>
104a71: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104a78: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
104a7f: 90 nop
104a80: 89 c3 mov %eax,%ebx <== NOT EXECUTED
rtems_rbtree_compare_result compare_result;
parent = *which;
compare_result = ( *compare )( the_node, parent );
104a82: 89 5c 24 04 mov %ebx,0x4(%esp)
104a86: 89 34 24 mov %esi,(%esp)
104a89: ff d7 call *%edi
if ( is_unique && rtems_rbtree_is_equal( compare_result ) ) {
104a8b: 85 c0 test %eax,%eax
104a8d: 75 06 jne 104a95 <rtems_rbtree_insert+0x45>
104a8f: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
104a93: 75 39 jne 104ace <rtems_rbtree_insert+0x7e>
return &RB_RIGHT( the_node, Node );
104a95: 8d 4b 04 lea 0x4(%ebx),%ecx
return parent;
}
if ( rtems_rbtree_is_lesser( compare_result ) ) {
104a98: 85 c0 test %eax,%eax
104a9a: 79 02 jns 104a9e <rtems_rbtree_insert+0x4e>
return &RB_LEFT( the_node, Node );
104a9c: 89 d9 mov %ebx,%ecx
while ( *which != NULL ) {
104a9e: 8b 01 mov (%ecx),%eax
104aa0: 85 c0 test %eax,%eax
104aa2: 75 dc jne 104a80 <rtems_rbtree_insert+0x30>
RB_SET( child, parent, Node );
104aa4: 89 5e 08 mov %ebx,0x8(%esi)
}
}
_RBTree_Initialize_node( the_node );
_RBTree_Add_child( the_node, parent, which );
_RBTree_Insert_color( the_rbtree, the_node );
104aa7: 8b 45 08 mov 0x8(%ebp),%eax
return NULL;
104aaa: 31 db xor %ebx,%ebx
104aac: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi)
104ab3: c7 06 00 00 00 00 movl $0x0,(%esi)
104ab9: c7 46 0c 01 00 00 00 movl $0x1,0xc(%esi)
*link = child;
104ac0: 89 31 mov %esi,(%ecx)
_RBTree_Insert_color( the_rbtree, the_node );
104ac2: 89 74 24 04 mov %esi,0x4(%esp)
104ac6: 89 04 24 mov %eax,(%esp)
104ac9: e8 02 1b 00 00 call 1065d0 <_RBTree_Insert_color>
}
104ace: 83 c4 2c add $0x2c,%esp
104ad1: 89 d8 mov %ebx,%eax
104ad3: 5b pop %ebx
104ad4: 5e pop %esi
104ad5: 5f pop %edi
104ad6: 5d pop %ebp
104ad7: c3 ret
return &RB_ROOT( the_rbtree );
104ad8: 8b 4d 08 mov 0x8(%ebp),%ecx
104adb: eb c7 jmp 104aa4 <rtems_rbtree_insert+0x54>
104add: 90 nop
104ade: 90 nop
104adf: 90 nop