RTEMS-5
Annotated Report
Fri Aug 10 14:03:21 2018
4000a77c <_rtld_linkmap_add>:
int
_rtld_linkmap_add (rtems_rtl_obj* obj)
{
4000a77c: 9d e3 bf a0 save %sp, -96, %sp
struct link_map* l = obj->linkmap;
struct link_map* prev;
uint32_t obj_num = obj->obj_num;
int i;
if (rtems_rtl_trace (RTEMS_RTL_TRACE_DETAIL))
4000a780: 90 10 20 01 mov 1, %o0
struct link_map* l = obj->linkmap;
4000a784: f4 06 20 88 ld [ %i0 + 0x88 ], %i2
if (rtems_rtl_trace (RTEMS_RTL_TRACE_DETAIL))
4000a788: 40 00 17 9f call 40010604 <rtems_rtl_trace>
4000a78c: fa 06 20 84 ld [ %i0 + 0x84 ], %i5
4000a790: 80 a2 20 00 cmp %o0, 0
4000a794: 12 80 00 23 bne 4000a820 <_rtld_linkmap_add+0xa4>
4000a798: 11 10 00 c1 sethi %hi(0x40030400), %o0
printf ("rtl: linkmap_add\n");
for (i = 0; i < obj_num; ++i)
4000a79c: 80 a7 60 00 cmp %i5, 0
4000a7a0: 02 80 00 10 be 4000a7e0 <_rtld_linkmap_add+0x64>
<== NEVER TAKEN
4000a7a4: 84 5f 60 34 smul %i5, 0x34, %g2
{
l[i].sec_addr[rap_text] = obj->text_base;
4000a7a8: f6 06 20 54 ld [ %i0 + 0x54 ], %i3
l[i].sec_addr[rap_const] = obj->const_base;
4000a7ac: f8 06 20 5c ld [ %i0 + 0x5c ], %i4
l[i].sec_addr[rap_data] = obj->data_base;
4000a7b0: c8 06 20 68 ld [ %i0 + 0x68 ], %g4
l[i].sec_addr[rap_bss] = obj->bss_base;
4000a7b4: c6 06 20 6c ld [ %i0 + 0x6c ], %g3
4000a7b8: 82 06 a0 0c add %i2, 0xc, %g1
4000a7bc: 84 06 80 02 add %i2, %g2, %g2
4000a7c0: 84 00 a0 0c add %g2, 0xc, %g2
l[i].sec_addr[rap_text] = obj->text_base;
4000a7c4: f6 20 40 00 st %i3, [ %g1 ]
4000a7c8: 82 00 60 34 add %g1, 0x34, %g1
l[i].sec_addr[rap_const] = obj->const_base;
4000a7cc: f8 20 7f d0 st %i4, [ %g1 + -48 ]
for (i = 0; i < obj_num; ++i)
4000a7d0: 80 a0 40 02 cmp %g1, %g2
l[i].sec_addr[rap_data] = obj->data_base;
4000a7d4: c8 20 7f dc st %g4, [ %g1 + -36 ]
for (i = 0; i < obj_num; ++i)
4000a7d8: 12 bf ff fb bne 4000a7c4 <_rtld_linkmap_add+0x48>
4000a7dc: c6 20 7f e0 st %g3, [ %g1 + -32 ]
}
if (_rtld_debug.r_map == NULL)
4000a7e0: 03 10 00 d9 sethi %hi(0x40036400), %g1
4000a7e4: 82 10 63 c0 or %g1, 0x3c0, %g1 ! 400367c0 <_rtld_debug>
4000a7e8: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000a7ec: 80 a0 a0 00 cmp %g2, 0
4000a7f0: 32 80 00 05 bne,a 4000a804 <_rtld_linkmap_add+0x88>
4000a7f4: c2 00 a0 2c ld [ %g2 + 0x2c ], %g1
4000a7f8: 10 80 00 0e b 4000a830 <_rtld_linkmap_add+0xb4>
4000a7fc: f4 20 60 04 st %i2, [ %g1 + 4 ]
{
_rtld_debug.r_map = l;
return true;
}
for (prev = _rtld_debug.r_map; prev->l_next != NULL; prev = prev->l_next);
4000a800: c2 00 a0 2c ld [ %g2 + 0x2c ], %g1
<== NOT EXECUTED
4000a804: 80 a0 60 00 cmp %g1, 0
4000a808: 32 bf ff fe bne,a 4000a800 <_rtld_linkmap_add+0x84>
<== NEVER TAKEN
4000a80c: 84 10 00 01 mov %g1, %g2
<== NOT EXECUTED
l->l_prev = prev;
4000a810: c4 26 a0 30 st %g2, [ %i2 + 0x30 ]
prev->l_next = l;
4000a814: f4 20 a0 2c st %i2, [ %g2 + 0x2c ]
return true;
}
4000a818: 81 c7 e0 08 ret
4000a81c: 91 e8 20 01 restore %g0, 1, %o0
printf ("rtl: linkmap_add\n");
4000a820: 40 00 38 59 call 40018984 <__wrap_puts>
4000a824: 90 12 22 58 or %o0, 0x258, %o0
for (i = 0; i < obj_num; ++i)
4000a828: 10 bf ff de b 4000a7a0 <_rtld_linkmap_add+0x24>
4000a82c: 80 a7 60 00 cmp %i5, 0
}
4000a830: 81 c7 e0 08 ret
4000a834: 91 e8 20 01 restore %g0, 1, %o0
4000a838 <_rtld_linkmap_delete>:
void
_rtld_linkmap_delete (rtems_rtl_obj* obj)
{
struct link_map* l = obj->linkmap;
4000a838: c4 02 20 88 ld [ %o0 + 0x88 ], %g2
/*
* link_maps are allocated together if not 1
*/
struct link_map* e = l + obj->obj_num - 1;
4000a83c: c2 02 20 84 ld [ %o0 + 0x84 ], %g1
4000a840: 82 58 60 34 smul %g1, 0x34, %g1
4000a844: 82 00 7f cc add %g1, -52, %g1
while (e && e->l_next) e = e->l_next;
4000a848: 82 80 80 01 addcc %g2, %g1, %g1
4000a84c: 02 80 00 0c be 4000a87c <_rtld_linkmap_delete+0x44>
<== NEVER TAKEN
4000a850: c6 00 a0 30 ld [ %g2 + 0x30 ], %g3
4000a854: c2 00 60 2c ld [ %g1 + 0x2c ], %g1
4000a858: 80 a0 60 00 cmp %g1, 0
4000a85c: 32 bf ff ff bne,a 4000a858 <_rtld_linkmap_delete+0x20>
4000a860: c2 00 60 2c ld [ %g1 + 0x2c ], %g1
if (l->l_prev == NULL)
4000a864: 80 a0 e0 00 cmp %g3, 0
4000a868: 22 80 00 14 be,a 4000a8b8 <_rtld_linkmap_delete+0x80>
4000a86c: 03 10 00 d9 sethi %hi(0x40036400), %g1
if ((_rtld_debug.r_map = e->l_next) != NULL)
e->l_next->l_prev = NULL;
return;
}
if ((l->l_prev->l_next = e->l_next) != NULL)
4000a870: c0 20 e0 2c clr [ %g3 + 0x2c ]
e->l_next->l_prev = l->l_prev;
}
4000a874: 81 c3 e0 08 retl
4000a878: 01 00 00 00 nop
if (l->l_prev == NULL)
4000a87c: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
4000a880: 02 80 00 08 be 4000a8a0 <_rtld_linkmap_delete+0x68>
<== NOT EXECUTED
4000a884: c2 00 20 2c ld [ 0x2c ], %g1
<== NOT EXECUTED
if ((l->l_prev->l_next = e->l_next) != NULL)
4000a888: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000a88c: 02 bf ff fa be 4000a874 <_rtld_linkmap_delete+0x3c>
<== NOT EXECUTED
4000a890: c2 20 e0 2c st %g1, [ %g3 + 0x2c ]
<== NOT EXECUTED
e->l_next->l_prev = l->l_prev;
4000a894: c2 00 20 2c ld [ 0x2c ], %g1
<== NOT EXECUTED
4000a898: 81 c3 e0 08 retl
<== NOT EXECUTED
4000a89c: c6 20 60 30 st %g3, [ %g1 + 0x30 ]
<== NOT EXECUTED
if ((_rtld_debug.r_map = e->l_next) != NULL)
4000a8a0: 05 10 00 d9 sethi %hi(0x40036400), %g2
<== NOT EXECUTED
4000a8a4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000a8a8: 02 bf ff f3 be 4000a874 <_rtld_linkmap_delete+0x3c>
<== NOT EXECUTED
4000a8ac: c2 20 a3 c4 st %g1, [ %g2 + 0x3c4 ]
<== NOT EXECUTED
e->l_next->l_prev = NULL;
4000a8b0: 81 c3 e0 08 retl
<== NOT EXECUTED
4000a8b4: c0 20 60 30 clr [ %g1 + 0x30 ]
<== NOT EXECUTED
if ((_rtld_debug.r_map = e->l_next) != NULL)
4000a8b8: 81 c3 e0 08 retl
4000a8bc: c0 20 63 c4 clr [ %g1 + 0x3c4 ]
40009e2c <dlclose>:
int
dlclose (void* handle)
{
40009e2c: 9d e3 bf 98 save %sp, -104, %sp
rtems_rtl_obj* obj;
int r;
if (!rtems_rtl_lock ())
40009e30: 40 00 09 81 call 4000c434 <rtems_rtl_lock>
40009e34: 01 00 00 00 nop
40009e38: 80 a2 20 00 cmp %o0, 0
40009e3c: 02 80 00 17 be 40009e98 <dlclose+0x6c>
<== NEVER TAKEN
40009e40: 01 00 00 00 nop
return -1;
obj = rtems_rtl_check_handle (handle);
40009e44: 40 00 0a 86 call 4000c85c <rtems_rtl_check_handle>
40009e48: 90 10 00 18 mov %i0, %o0
if (!obj)
40009e4c: 80 a2 20 00 cmp %o0, 0
40009e50: 02 80 00 14 be 40009ea0 <dlclose+0x74>
<== NEVER TAKEN
40009e54: 82 10 20 02 mov 2, %g1
40009e58: d0 27 bf fc st %o0, [ %fp + -4 ]
{
rtems_rtl_unlock ();
return -1;
}
_rtld_debug.r_state = RT_DELETE;
40009e5c: 3b 10 00 d9 sethi %hi(0x40036400), %i5
40009e60: ba 17 63 c0 or %i5, 0x3c0, %i5 ! 400367c0 <_rtld_debug>
_rtld_debug_state ();
40009e64: 40 00 02 44 call 4000a774 <_rtld_debug_state>
40009e68: c2 27 60 08 st %g1, [ %i5 + 8 ]
r = rtems_rtl_unload_object (obj) ? 0 : -1;
40009e6c: 40 00 0b 21 call 4000caf0 <rtems_rtl_unload_object>
40009e70: d0 07 bf fc ld [ %fp + -4 ], %o0
_rtld_debug.r_state = RT_CONSISTENT;
40009e74: c0 27 60 08 clr [ %i5 + 8 ]
r = rtems_rtl_unload_object (obj) ? 0 : -1;
40009e78: b0 1a 20 01 xor %o0, 1, %i0
40009e7c: b0 0e 20 ff and %i0, 0xff, %i0
_rtld_debug_state ();
40009e80: 40 00 02 3d call 4000a774 <_rtld_debug_state>
40009e84: b0 20 00 18 neg %i0
rtems_rtl_unlock ();
40009e88: 40 00 0a 70 call 4000c848 <rtems_rtl_unlock>
40009e8c: 01 00 00 00 nop
return r;
40009e90: 81 c7 e0 08 ret
40009e94: 81 e8 00 00 restore
}
40009e98: 81 c7 e0 08 ret
<== NOT EXECUTED
40009e9c: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
rtems_rtl_unlock ();
40009ea0: 40 00 0a 6a call 4000c848 <rtems_rtl_unlock>
<== NOT EXECUTED
40009ea4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
return -1;
40009ea8: 81 c7 e0 08 ret
<== NOT EXECUTED
40009eac: 81 e8 00 00 restore
<== NOT EXECUTED
40009f70 <dlinfo>:
int
dlinfo (void* handle, int request, void* p)
{
40009f70: 9d e3 bf a0 save %sp, -96, %sp
rtems_rtl_obj* obj;
int rc = -1;
if (!rtems_rtl_lock () || !p)
40009f74: 40 00 09 30 call 4000c434 <rtems_rtl_lock>
40009f78: 01 00 00 00 nop
40009f7c: 80 a6 a0 00 cmp %i2, 0
40009f80: 02 80 00 1d be 40009ff4 <dlinfo+0x84>
<== NEVER TAKEN
40009f84: 80 a2 20 00 cmp %o0, 0
40009f88: 02 80 00 1b be 40009ff4 <dlinfo+0x84>
<== NEVER TAKEN
40009f8c: 82 06 20 03 add %i0, 3, %g1
if ((handle == RTLD_DEFAULT) || (handle == RTLD_SELF))
40009f90: 80 a0 60 01 cmp %g1, 1
40009f94: 08 80 00 14 bleu 40009fe4 <dlinfo+0x74>
<== NEVER TAKEN
40009f98: 01 00 00 00 nop
obj = rtems_rtl_check_handle (handle);
40009f9c: 40 00 0a 30 call 4000c85c <rtems_rtl_check_handle>
40009fa0: 90 10 00 18 mov %i0, %o0
int rc = -1;
40009fa4: b0 10 3f ff mov -1, %i0
return -1;
obj = dl_get_obj_from_handle (handle);
if (obj)
40009fa8: 80 a2 20 00 cmp %o0, 0
40009fac: 02 80 00 04 be 40009fbc <dlinfo+0x4c>
<== NEVER TAKEN
40009fb0: 80 a6 60 0a cmp %i1, 0xa
{
switch (request)
40009fb4: 02 80 00 06 be 40009fcc <dlinfo+0x5c>
<== ALWAYS TAKEN
40009fb8: 01 00 00 00 nop
default:
break;
}
}
rtems_rtl_unlock ();
40009fbc: 40 00 0a 23 call 4000c848 <rtems_rtl_unlock>
<== NOT EXECUTED
40009fc0: 01 00 00 00 nop
<== NOT EXECUTED
return rc;
40009fc4: 81 c7 e0 08 ret
<== NOT EXECUTED
40009fc8: 81 e8 00 00 restore
<== NOT EXECUTED
*((int*) p) = rtems_rtl_obj_unresolved (obj) ? 1 : 0;
40009fcc: 40 00 0f 20 call 4000dc4c <rtems_rtl_obj_unresolved>
40009fd0: b0 10 20 00 clr %i0
rtems_rtl_unlock ();
40009fd4: 40 00 0a 1d call 4000c848 <rtems_rtl_unlock>
40009fd8: d0 26 80 00 st %o0, [ %i2 ]
return rc;
40009fdc: 81 c7 e0 08 ret
40009fe0: 81 e8 00 00 restore
obj = rtems_rtl_baseimage ();
40009fe4: 40 00 0b 1d call 4000cc58 <rtems_rtl_baseimage>
<== NOT EXECUTED
40009fe8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
if (obj)
40009fec: 10 bf ff f0 b 40009fac <dlinfo+0x3c>
<== NOT EXECUTED
40009ff0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
}
40009ff4: 81 c7 e0 08 ret
<== NOT EXECUTED
40009ff8: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
40009da8 <dlopen>:
return obj;
}
void*
dlopen (const char* name, int mode)
{
40009da8: 9d e3 bf a0 save %sp, -96, %sp
rtems_rtl_obj* obj = NULL;
if (!rtems_rtl_lock ())
40009dac: 40 00 09 a2 call 4000c434 <rtems_rtl_lock>
40009db0: 01 00 00 00 nop
40009db4: 80 a2 20 00 cmp %o0, 0
40009db8: 02 80 00 1b be 40009e24 <dlopen+0x7c>
<== NEVER TAKEN
40009dbc: 82 10 20 01 mov 1, %g1
return NULL;
_rtld_debug.r_state = RT_ADD;
40009dc0: 3b 10 00 d9 sethi %hi(0x40036400), %i5
40009dc4: ba 17 63 c0 or %i5, 0x3c0, %i5 ! 400367c0 <_rtld_debug>
_rtld_debug_state ();
40009dc8: 40 00 02 6b call 4000a774 <_rtld_debug_state>
40009dcc: c2 27 60 08 st %g1, [ %i5 + 8 ]
if (name)
40009dd0: 80 a6 20 00 cmp %i0, 0
40009dd4: 02 80 00 0b be 40009e00 <dlopen+0x58>
<== NEVER TAKEN
40009dd8: 92 10 00 19 mov %i1, %o1
obj = rtems_rtl_load_object (name, mode);
40009ddc: 40 00 0a f6 call 4000c9b4 <rtems_rtl_load_object>
40009de0: 90 10 00 18 mov %i0, %o0
else
obj = rtems_rtl_baseimage ();
_rtld_debug.r_state = RT_CONSISTENT;
40009de4: c0 27 60 08 clr [ %i5 + 8 ]
_rtld_debug_state();
40009de8: 40 00 02 63 call 4000a774 <_rtld_debug_state>
40009dec: b0 10 00 08 mov %o0, %i0
rtems_rtl_unlock ();
40009df0: 40 00 0a 96 call 4000c848 <rtems_rtl_unlock>
40009df4: 01 00 00 00 nop
return obj;
40009df8: 81 c7 e0 08 ret
40009dfc: 81 e8 00 00 restore
obj = rtems_rtl_baseimage ();
40009e00: 40 00 0b 96 call 4000cc58 <rtems_rtl_baseimage>
<== NOT EXECUTED
40009e04: 01 00 00 00 nop
<== NOT EXECUTED
_rtld_debug.r_state = RT_CONSISTENT;
40009e08: c0 27 60 08 clr [ %i5 + 8 ]
<== NOT EXECUTED
_rtld_debug_state();
40009e0c: 40 00 02 5a call 4000a774 <_rtld_debug_state>
<== NOT EXECUTED
40009e10: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
rtems_rtl_unlock ();
40009e14: 40 00 0a 8d call 4000c848 <rtems_rtl_unlock>
<== NOT EXECUTED
40009e18: 01 00 00 00 nop
<== NOT EXECUTED
return obj;
40009e1c: 81 c7 e0 08 ret
<== NOT EXECUTED
40009e20: 81 e8 00 00 restore
<== NOT EXECUTED
}
40009e24: 81 c7 e0 08 ret
<== NOT EXECUTED
40009e28: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
40009eb0 <dlsym>:
void*
dlsym (void* handle, const char *symbol)
{
40009eb0: 9d e3 bf a0 save %sp, -96, %sp
rtems_rtl_obj* obj;
rtems_rtl_obj_sym* sym = NULL;
void* symval = NULL;
if (!rtems_rtl_lock ())
40009eb4: 40 00 09 60 call 4000c434 <rtems_rtl_lock>
40009eb8: 01 00 00 00 nop
40009ebc: 80 a2 20 00 cmp %o0, 0
40009ec0: 02 80 00 22 be 40009f48 <dlsym+0x98>
<== NEVER TAKEN
40009ec4: 80 a6 3f fe cmp %i0, -2
return NULL;
/*
* If the handle is "default" search the global symbol table.
*/
if (handle == RTLD_DEFAULT)
40009ec8: 02 80 00 1c be 40009f38 <dlsym+0x88>
40009ecc: 82 06 20 03 add %i0, 3, %g1
if ((handle == RTLD_DEFAULT) || (handle == RTLD_SELF))
40009ed0: 80 a0 60 01 cmp %g1, 1
40009ed4: 08 80 00 10 bleu 40009f14 <dlsym+0x64>
<== NEVER TAKEN
40009ed8: 01 00 00 00 nop
obj = rtems_rtl_check_handle (handle);
40009edc: 40 00 0a 60 call 4000c85c <rtems_rtl_check_handle>
40009ee0: 90 10 00 18 mov %i0, %o0
sym = rtems_rtl_symbol_global_find (symbol);
}
else
{
obj = dl_get_obj_from_handle (handle);
if (obj)
40009ee4: 80 a2 20 00 cmp %o0, 0
40009ee8: 02 80 00 10 be 40009f28 <dlsym+0x78>
<== NEVER TAKEN
40009eec: 01 00 00 00 nop
sym = rtems_rtl_symbol_obj_find (obj, symbol);
40009ef0: 40 00 19 5a call 40010458 <rtems_rtl_symbol_obj_find>
40009ef4: 92 10 00 19 mov %i1, %o1
}
if (sym)
40009ef8: 80 a2 20 00 cmp %o0, 0
40009efc: 02 80 00 0b be 40009f28 <dlsym+0x78>
<== NEVER TAKEN
40009f00: 01 00 00 00 nop
symval = sym->value;
rtems_rtl_unlock ();
40009f04: 40 00 0a 51 call 4000c848 <rtems_rtl_unlock>
40009f08: f0 02 20 0c ld [ %o0 + 0xc ], %i0
return symval;
40009f0c: 81 c7 e0 08 ret
40009f10: 81 e8 00 00 restore
obj = rtems_rtl_baseimage ();
40009f14: 40 00 0b 51 call 4000cc58 <rtems_rtl_baseimage>
<== NOT EXECUTED
40009f18: 01 00 00 00 nop
<== NOT EXECUTED
if (obj)
40009f1c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40009f20: 12 bf ff f4 bne 40009ef0 <dlsym+0x40>
<== NOT EXECUTED
40009f24: 01 00 00 00 nop
<== NOT EXECUTED
rtems_rtl_unlock ();
40009f28: 40 00 0a 48 call 4000c848 <rtems_rtl_unlock>
<== NOT EXECUTED
40009f2c: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
return symval;
40009f30: 81 c7 e0 08 ret
<== NOT EXECUTED
40009f34: 81 e8 00 00 restore
<== NOT EXECUTED
sym = rtems_rtl_symbol_global_find (symbol);
40009f38: 40 00 18 6f call 400100f4 <rtems_rtl_symbol_global_find>
40009f3c: 90 10 00 19 mov %i1, %o0
40009f40: 10 bf ff ef b 40009efc <dlsym+0x4c>
40009f44: 80 a2 20 00 cmp %o0, 0
}
40009f48: 81 c7 e0 08 ret
<== NOT EXECUTED
40009f4c: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
40009ffc <fastlz_decompress>:
/* else... */
return fastlz2_compress(input, length, output);
}
int fastlz_decompress(const void* input, int length, void* output, int maxout)
{
40009ffc: 9d e3 bf a0 save %sp, -96, %sp
/* magic identifier for compression level */
int level = ((*(const flzuint8*)input) >> 5) + 1;
4000a000: c4 0e 00 00 ldub [ %i0 ], %g2
4000a004: 83 30 a0 05 srl %g2, 5, %g1
4000a008: 82 00 60 01 inc %g1
if(level == 1)
4000a00c: 80 a0 60 01 cmp %g1, 1
4000a010: 02 80 00 6f be 4000a1cc <fastlz_decompress+0x1d0>
<== ALWAYS TAKEN
4000a014: 80 a0 60 02 cmp %g1, 2
return fastlz1_decompress(input, length, output, maxout);
if(level == 2)
4000a018: 02 80 00 04 be 4000a028 <fastlz_decompress+0x2c>
<== NOT EXECUTED
4000a01c: b2 06 00 19 add %i0, %i1, %i1
<== NOT EXECUTED
}
#endif
#ifdef FASTLZ_SAFE
if (FASTLZ_UNEXPECT_CONDITIONAL(op + len + 3 > op_limit))
return 0;
4000a020: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a024: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
flzuint32 ofs = (ctrl & 31) << 8;
4000a028: 39 00 00 07 sethi %hi(0x1c00), %i4
<== NOT EXECUTED
ref = op - ofs - MAX_DISTANCE;
4000a02c: 1f 3f ff f8 sethi %hi(0xffffe000), %o7
<== NOT EXECUTED
flzuint8* op_limit = op + maxout;
4000a030: b6 06 80 1b add %i2, %i3, %i3
<== NOT EXECUTED
flzuint32 ctrl = (*ip++) & 31;
4000a034: b0 06 20 01 inc %i0
<== NOT EXECUTED
4000a038: 84 08 a0 1f and %g2, 0x1f, %g2
<== NOT EXECUTED
4000a03c: 82 10 00 1a mov %i2, %g1
<== NOT EXECUTED
flzuint32 ofs = (ctrl & 31) << 8;
4000a040: b8 17 23 00 or %i4, 0x300, %i4
<== NOT EXECUTED
ref = op - ofs - MAX_DISTANCE;
4000a044: 9e 13 e0 01 or %o7, 1, %o7
<== NOT EXECUTED
if(ctrl >= 32)
4000a048: 80 a0 a0 1f cmp %g2, 0x1f
<== NOT EXECUTED
4000a04c: 08 80 00 44 bleu 4000a15c <fastlz_decompress+0x160>
<== NOT EXECUTED
4000a050: 87 30 a0 05 srl %g2, 5, %g3
<== NOT EXECUTED
len--;
4000a054: 86 00 ff ff add %g3, -1, %g3
<== NOT EXECUTED
if (len == 7-1)
4000a058: 80 a0 e0 06 cmp %g3, 6
<== NOT EXECUTED
4000a05c: 22 80 00 35 be,a 4000a130 <fastlz_decompress+0x134>
<== NOT EXECUTED
4000a060: c8 0e 00 00 ldub [ %i0 ], %g4
<== NOT EXECUTED
ref -= code;
4000a064: c8 0e 00 00 ldub [ %i0 ], %g4
<== NOT EXECUTED
flzuint32 ofs = (ctrl & 31) << 8;
4000a068: bb 28 a0 08 sll %g2, 8, %i5
<== NOT EXECUTED
if(FASTLZ_EXPECT_CONDITIONAL(ofs==(31 << 8)))
4000a06c: 80 a1 20 ff cmp %g4, 0xff
<== NOT EXECUTED
flzuint32 ofs = (ctrl & 31) << 8;
4000a070: ba 0f 40 1c and %i5, %i4, %i5
<== NOT EXECUTED
code = *ip++;
4000a074: 9a 06 20 01 add %i0, 1, %o5
<== NOT EXECUTED
ref -= code;
4000a078: 88 01 00 1d add %g4, %i5, %g4
<== NOT EXECUTED
if(FASTLZ_EXPECT_CONDITIONAL(ofs==(31 << 8)))
4000a07c: 12 80 00 05 bne 4000a090 <fastlz_decompress+0x94>
<== NOT EXECUTED
4000a080: 88 20 40 04 sub %g1, %g4, %g4
<== NOT EXECUTED
4000a084: 80 a7 40 1c cmp %i5, %i4
<== NOT EXECUTED
4000a088: 22 80 00 ca be,a 4000a3b0 <fastlz_decompress+0x3b4>
<== NOT EXECUTED
4000a08c: c8 0e 20 02 ldub [ %i0 + 2 ], %g4
<== NOT EXECUTED
if (FASTLZ_UNEXPECT_CONDITIONAL(op + len + 3 > op_limit))
4000a090: ba 00 e0 03 add %g3, 3, %i5
<== NOT EXECUTED
4000a094: ba 00 40 1d add %g1, %i5, %i5
<== NOT EXECUTED
4000a098: 80 a6 c0 1d cmp %i3, %i5
<== NOT EXECUTED
4000a09c: 0a bf ff e1 bcs 4000a020 <fastlz_decompress+0x24>
<== NOT EXECUTED
4000a0a0: ba 01 3f ff add %g4, -1, %i5
<== NOT EXECUTED
if (FASTLZ_UNEXPECT_CONDITIONAL(ref-1 < (flzuint8 *)output))
4000a0a4: 80 a6 80 1d cmp %i2, %i5
<== NOT EXECUTED
4000a0a8: 18 bf ff de bgu 4000a020 <fastlz_decompress+0x24>
<== NOT EXECUTED
4000a0ac: 80 a6 40 0d cmp %i1, %o5
<== NOT EXECUTED
return 0;
#endif
if(FASTLZ_EXPECT_CONDITIONAL(ip < ip_limit))
4000a0b0: 08 80 00 c7 bleu 4000a3cc <fastlz_decompress+0x3d0>
<== NOT EXECUTED
4000a0b4: b0 10 00 0d mov %o5, %i0
<== NOT EXECUTED
ctrl = *ip++;
4000a0b8: c4 0b 40 00 ldub [ %o5 ], %g2
<== NOT EXECUTED
4000a0bc: b0 03 60 01 add %o5, 1, %i0
<== NOT EXECUTED
4000a0c0: 98 10 20 01 mov 1, %o4
<== NOT EXECUTED
else
loop = 0;
if(ref == op)
4000a0c4: 80 a0 40 04 cmp %g1, %g4
<== NOT EXECUTED
4000a0c8: 02 80 00 9c be 4000a338 <fastlz_decompress+0x33c>
<== NOT EXECUTED
4000a0cc: ba 00 60 03 add %g1, 3, %i5
<== NOT EXECUTED
const flzuint16* p;
flzuint16* q;
#endif
/* copy from reference */
ref--;
*op++ = *ref++;
4000a0d0: da 09 3f ff ldub [ %g4 + -1 ], %o5
<== NOT EXECUTED
4000a0d4: da 28 40 00 stb %o5, [ %g1 ]
<== NOT EXECUTED
*op++ = *ref++;
*op++ = *ref++;
4000a0d8: 9a 01 20 02 add %g4, 2, %o5
<== NOT EXECUTED
*op++ = *ref++;
4000a0dc: d6 09 00 00 ldub [ %g4 ], %o3
<== NOT EXECUTED
4000a0e0: d6 28 60 01 stb %o3, [ %g1 + 1 ]
<== NOT EXECUTED
*q++ = *p++;
}
for(; len; --len)
*q++ = *p++;
#else
for(; len; --len)
4000a0e4: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
*op++ = *ref++;
4000a0e8: c8 09 20 01 ldub [ %g4 + 1 ], %g4
<== NOT EXECUTED
for(; len; --len)
4000a0ec: 02 80 00 ad be 4000a3a0 <fastlz_decompress+0x3a4>
<== NOT EXECUTED
4000a0f0: c8 28 60 02 stb %g4, [ %g1 + 2 ]
<== NOT EXECUTED
4000a0f4: 82 10 20 00 clr %g1
<== NOT EXECUTED
*op++ = *ref++;
4000a0f8: c8 0b 40 01 ldub [ %o5 + %g1 ], %g4
<== NOT EXECUTED
4000a0fc: c8 2f 40 01 stb %g4, [ %i5 + %g1 ]
<== NOT EXECUTED
4000a100: 82 00 60 01 inc %g1
<== NOT EXECUTED
for(; len; --len)
4000a104: 80 a0 c0 01 cmp %g3, %g1
<== NOT EXECUTED
4000a108: 32 bf ff fd bne,a 4000a0fc <fastlz_decompress+0x100>
<== NOT EXECUTED
4000a10c: c8 0b 40 01 ldub [ %o5 + %g1 ], %g4
<== NOT EXECUTED
4000a110: 82 07 40 03 add %i5, %g3, %g1
<== NOT EXECUTED
loop = FASTLZ_EXPECT_CONDITIONAL(ip < ip_limit);
if(loop)
ctrl = *ip++;
}
}
while(FASTLZ_EXPECT_CONDITIONAL(loop));
4000a114: 80 a3 20 00 cmp %o4, 0
<== NOT EXECUTED
4000a118: 12 bf ff cd bne 4000a04c <fastlz_decompress+0x50>
<== NOT EXECUTED
4000a11c: 80 a0 a0 1f cmp %g2, 0x1f
<== NOT EXECUTED
return op - (flzuint8*)output;
4000a120: b0 20 40 1a sub %g1, %i2, %i0
<== NOT EXECUTED
}
4000a124: 81 c7 e0 08 ret
4000a128: 81 e8 00 00 restore
len += code;
4000a12c: c8 0e 00 00 ldub [ %i0 ], %g4
<== NOT EXECUTED
4000a130: 86 00 c0 04 add %g3, %g4, %g3
<== NOT EXECUTED
} while (code==255);
4000a134: 80 a1 20 ff cmp %g4, 0xff
<== NOT EXECUTED
4000a138: 12 bf ff cb bne 4000a064 <fastlz_decompress+0x68>
<== NOT EXECUTED
4000a13c: b0 06 20 01 inc %i0
<== NOT EXECUTED
len += code;
4000a140: c8 0e 00 00 ldub [ %i0 ], %g4
<== NOT EXECUTED
4000a144: 86 00 c0 04 add %g3, %g4, %g3
<== NOT EXECUTED
} while (code==255);
4000a148: 80 a1 20 ff cmp %g4, 0xff
<== NOT EXECUTED
4000a14c: 02 bf ff f8 be 4000a12c <fastlz_decompress+0x130>
<== NOT EXECUTED
4000a150: b0 06 20 01 inc %i0
<== NOT EXECUTED
ref -= code;
4000a154: 10 bf ff c5 b 4000a068 <fastlz_decompress+0x6c>
<== NOT EXECUTED
4000a158: c8 0e 00 00 ldub [ %i0 ], %g4
<== NOT EXECUTED
ctrl++;
4000a15c: ba 00 a0 01 add %g2, 1, %i5
<== NOT EXECUTED
if (FASTLZ_UNEXPECT_CONDITIONAL(op + ctrl > op_limit))
4000a160: 86 00 40 1d add %g1, %i5, %g3
<== NOT EXECUTED
4000a164: 80 a6 c0 03 cmp %i3, %g3
<== NOT EXECUTED
4000a168: 0a bf ff ae bcs 4000a020 <fastlz_decompress+0x24>
<== NOT EXECUTED
4000a16c: 86 06 00 1d add %i0, %i5, %g3
<== NOT EXECUTED
if (FASTLZ_UNEXPECT_CONDITIONAL(ip + ctrl > ip_limit))
4000a170: 80 a6 40 03 cmp %i1, %g3
<== NOT EXECUTED
4000a174: 0a bf ff ab bcs 4000a020 <fastlz_decompress+0x24>
<== NOT EXECUTED
4000a178: 9a 06 20 01 add %i0, 1, %o5
<== NOT EXECUTED
*op++ = *ip++;
4000a17c: c6 0e 00 00 ldub [ %i0 ], %g3
<== NOT EXECUTED
4000a180: c6 28 40 00 stb %g3, [ %g1 ]
<== NOT EXECUTED
for(--ctrl; ctrl; ctrl--)
4000a184: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000a188: 02 80 00 95 be 4000a3dc <fastlz_decompress+0x3e0>
<== NOT EXECUTED
4000a18c: 98 00 60 01 add %g1, 1, %o4
<== NOT EXECUTED
4000a190: 88 10 20 01 mov 1, %g4
<== NOT EXECUTED
*op++ = *ip++;
4000a194: c6 0e 00 04 ldub [ %i0 + %g4 ], %g3
<== NOT EXECUTED
4000a198: c6 28 40 04 stb %g3, [ %g1 + %g4 ]
<== NOT EXECUTED
4000a19c: 88 01 20 01 inc %g4
<== NOT EXECUTED
for(--ctrl; ctrl; ctrl--)
4000a1a0: 80 a7 40 04 cmp %i5, %g4
<== NOT EXECUTED
4000a1a4: 32 bf ff fd bne,a 4000a198 <fastlz_decompress+0x19c>
<== NOT EXECUTED
4000a1a8: c6 0e 00 04 ldub [ %i0 + %g4 ], %g3
<== NOT EXECUTED
4000a1ac: 9a 03 40 02 add %o5, %g2, %o5
<== NOT EXECUTED
4000a1b0: 82 03 00 02 add %o4, %g2, %g1
<== NOT EXECUTED
if(loop)
4000a1b4: 80 a6 40 0d cmp %i1, %o5
<== NOT EXECUTED
4000a1b8: 28 bf ff db bleu,a 4000a124 <fastlz_decompress+0x128>
<== NOT EXECUTED
4000a1bc: b0 20 40 1a sub %g1, %i2, %i0
<== NOT EXECUTED
ctrl = *ip++;
4000a1c0: b0 03 60 01 add %o5, 1, %i0
<== NOT EXECUTED
4000a1c4: 10 bf ff a1 b 4000a048 <fastlz_decompress+0x4c>
<== NOT EXECUTED
4000a1c8: c4 0b 40 00 ldub [ %o5 ], %g2
<== NOT EXECUTED
const flzuint8* ip_limit = ip + length;
4000a1cc: b2 06 00 19 add %i0, %i1, %i1
flzuint32 ofs = (ctrl & 31) << 8;
4000a1d0: 1b 00 00 07 sethi %hi(0x1c00), %o5
flzuint8* op_limit = op + maxout;
4000a1d4: b6 06 80 1b add %i2, %i3, %i3
flzuint32 ctrl = (*ip++) & 31;
4000a1d8: b0 06 20 01 inc %i0
4000a1dc: 84 08 a0 1f and %g2, 0x1f, %g2
4000a1e0: 86 10 00 1a mov %i2, %g3
flzuint32 ofs = (ctrl & 31) << 8;
4000a1e4: 9a 13 63 00 or %o5, 0x300, %o5
if(ctrl >= 32)
4000a1e8: 80 a0 a0 1f cmp %g2, 0x1f
4000a1ec: 08 80 00 37 bleu 4000a2c8 <fastlz_decompress+0x2cc>
4000a1f0: bb 30 a0 05 srl %g2, 5, %i5
4000a1f4: 9e 06 20 01 add %i0, 1, %o7
len--;
4000a1f8: ba 07 7f ff add %i5, -1, %i5
if (len == 7-1)
4000a1fc: 80 a7 60 06 cmp %i5, 6
4000a200: 12 80 00 07 bne 4000a21c <fastlz_decompress+0x220>
4000a204: f8 0e 00 00 ldub [ %i0 ], %i4
4000a208: 82 06 20 02 add %i0, 2, %g1
len += *ip++;
4000a20c: ba 07 20 06 add %i4, 6, %i5
4000a210: f8 0e 20 01 ldub [ %i0 + 1 ], %i4
4000a214: b0 10 00 0f mov %o7, %i0
4000a218: 9e 10 00 01 mov %g1, %o7
flzuint32 ofs = (ctrl & 31) << 8;
4000a21c: 89 28 a0 08 sll %g2, 8, %g4
if (FASTLZ_UNEXPECT_CONDITIONAL(op + len + 3 > op_limit))
4000a220: 82 07 60 03 add %i5, 3, %g1
flzuint32 ofs = (ctrl & 31) << 8;
4000a224: 88 09 00 0d and %g4, %o5, %g4
if (FASTLZ_UNEXPECT_CONDITIONAL(op + len + 3 > op_limit))
4000a228: 82 00 c0 01 add %g3, %g1, %g1
ref -= *ip++;
4000a22c: 88 01 00 1c add %g4, %i4, %g4
if (FASTLZ_UNEXPECT_CONDITIONAL(op + len + 3 > op_limit))
4000a230: 80 a6 c0 01 cmp %i3, %g1
4000a234: 0a bf ff 7b bcs 4000a020 <fastlz_decompress+0x24>
<== NEVER TAKEN
4000a238: 88 20 c0 04 sub %g3, %g4, %g4
if (FASTLZ_UNEXPECT_CONDITIONAL(ref-1 < (flzuint8 *)output))
4000a23c: 82 01 3f ff add %g4, -1, %g1
4000a240: 80 a6 80 01 cmp %i2, %g1
4000a244: 18 bf ff 77 bgu 4000a020 <fastlz_decompress+0x24>
<== NEVER TAKEN
4000a248: 80 a6 40 0f cmp %i1, %o7
if(FASTLZ_EXPECT_CONDITIONAL(ip < ip_limit))
4000a24c: 28 80 00 62 bleu,a 4000a3d4 <fastlz_decompress+0x3d8>
<== NEVER TAKEN
4000a250: b0 10 00 0f mov %o7, %i0
<== NOT EXECUTED
ctrl = *ip++;
4000a254: c4 0e 20 01 ldub [ %i0 + 1 ], %g2
4000a258: 98 10 20 01 mov 1, %o4
4000a25c: b0 06 20 02 add %i0, 2, %i0
if(ref == op)
4000a260: 80 a0 c0 04 cmp %g3, %g4
4000a264: 02 80 00 42 be 4000a36c <fastlz_decompress+0x370>
4000a268: b8 00 e0 03 add %g3, 3, %i4
*op++ = *ref++;
4000a26c: c2 09 3f ff ldub [ %g4 + -1 ], %g1
4000a270: c2 28 c0 00 stb %g1, [ %g3 ]
*op++ = *ref++;
4000a274: 9e 01 20 02 add %g4, 2, %o7
*op++ = *ref++;
4000a278: c2 09 00 00 ldub [ %g4 ], %g1
4000a27c: c2 28 e0 01 stb %g1, [ %g3 + 1 ]
for(; len; --len)
4000a280: 80 a7 60 00 cmp %i5, 0
*op++ = *ref++;
4000a284: c2 09 20 01 ldub [ %g4 + 1 ], %g1
for(; len; --len)
4000a288: 02 80 00 48 be 4000a3a8 <fastlz_decompress+0x3ac>
4000a28c: c2 28 e0 02 stb %g1, [ %g3 + 2 ]
4000a290: 82 10 20 00 clr %g1
*op++ = *ref++;
4000a294: c6 0b c0 01 ldub [ %o7 + %g1 ], %g3
4000a298: c6 2f 00 01 stb %g3, [ %i4 + %g1 ]
4000a29c: 82 00 60 01 inc %g1
for(; len; --len)
4000a2a0: 80 a7 40 01 cmp %i5, %g1
4000a2a4: 32 bf ff fd bne,a 4000a298 <fastlz_decompress+0x29c>
4000a2a8: c6 0b c0 01 ldub [ %o7 + %g1 ], %g3
4000a2ac: 86 07 00 1d add %i4, %i5, %g3
while(FASTLZ_EXPECT_CONDITIONAL(loop));
4000a2b0: 80 a3 20 00 cmp %o4, 0
4000a2b4: 12 bf ff ce bne 4000a1ec <fastlz_decompress+0x1f0>
<== ALWAYS TAKEN
4000a2b8: 80 a0 a0 1f cmp %g2, 0x1f
return op - (flzuint8*)output;
4000a2bc: b0 20 c0 1a sub %g3, %i2, %i0
<== NOT EXECUTED
4000a2c0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a2c4: 81 e8 00 00 restore
<== NOT EXECUTED
ctrl++;
4000a2c8: ba 00 a0 01 add %g2, 1, %i5
if (FASTLZ_UNEXPECT_CONDITIONAL(op + ctrl > op_limit))
4000a2cc: 82 00 c0 1d add %g3, %i5, %g1
4000a2d0: 80 a6 c0 01 cmp %i3, %g1
4000a2d4: 0a bf ff 53 bcs 4000a020 <fastlz_decompress+0x24>
<== NEVER TAKEN
4000a2d8: 82 06 00 1d add %i0, %i5, %g1
if (FASTLZ_UNEXPECT_CONDITIONAL(ip + ctrl > ip_limit))
4000a2dc: 80 a6 40 01 cmp %i1, %g1
4000a2e0: 0a bf ff 50 bcs 4000a020 <fastlz_decompress+0x24>
<== NEVER TAKEN
4000a2e4: b8 06 20 01 add %i0, 1, %i4
*op++ = *ip++;
4000a2e8: c2 0e 00 00 ldub [ %i0 ], %g1
4000a2ec: c2 28 c0 00 stb %g1, [ %g3 ]
for(--ctrl; ctrl; ctrl--)
4000a2f0: 80 a0 a0 00 cmp %g2, 0
4000a2f4: 02 80 00 3c be 4000a3e4 <fastlz_decompress+0x3e8>
4000a2f8: 9e 00 e0 01 add %g3, 1, %o7
4000a2fc: 88 10 20 01 mov 1, %g4
*op++ = *ip++;
4000a300: c2 0e 00 04 ldub [ %i0 + %g4 ], %g1
4000a304: c2 28 c0 04 stb %g1, [ %g3 + %g4 ]
4000a308: 88 01 20 01 inc %g4
for(--ctrl; ctrl; ctrl--)
4000a30c: 80 a7 40 04 cmp %i5, %g4
4000a310: 32 bf ff fd bne,a 4000a304 <fastlz_decompress+0x308>
4000a314: c2 0e 00 04 ldub [ %i0 + %g4 ], %g1
4000a318: b8 07 00 02 add %i4, %g2, %i4
4000a31c: 86 03 c0 02 add %o7, %g2, %g3
if(loop)
4000a320: 80 a6 40 1c cmp %i1, %i4
4000a324: 28 bf ff 80 bleu,a 4000a124 <fastlz_decompress+0x128>
4000a328: b0 20 c0 1a sub %g3, %i2, %i0
ctrl = *ip++;
4000a32c: b0 07 20 01 add %i4, 1, %i0
4000a330: 10 bf ff ae b 4000a1e8 <fastlz_decompress+0x1ec>
4000a334: c4 0f 00 00 ldub [ %i4 ], %g2
flzuint8 b = ref[-1];
4000a338: c8 08 7f ff ldub [ %g1 + -1 ], %g4
<== NOT EXECUTED
*op++ = b;
4000a33c: c8 28 40 00 stb %g4, [ %g1 ]
<== NOT EXECUTED
for(; len; --len)
4000a340: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
*op++ = b;
4000a344: c8 28 60 01 stb %g4, [ %g1 + 1 ]
<== NOT EXECUTED
for(; len; --len)
4000a348: 02 80 00 16 be 4000a3a0 <fastlz_decompress+0x3a4>
<== NOT EXECUTED
4000a34c: c8 28 60 02 stb %g4, [ %g1 + 2 ]
<== NOT EXECUTED
4000a350: 82 07 40 03 add %i5, %g3, %g1
<== NOT EXECUTED
*op++ = b;
4000a354: ba 07 60 01 inc %i5
<== NOT EXECUTED
for(; len; --len)
4000a358: 80 a7 40 01 cmp %i5, %g1
<== NOT EXECUTED
4000a35c: 12 bf ff fe bne 4000a354 <fastlz_decompress+0x358>
<== NOT EXECUTED
4000a360: c8 2f 7f ff stb %g4, [ %i5 + -1 ]
<== NOT EXECUTED
while(FASTLZ_EXPECT_CONDITIONAL(loop));
4000a364: 10 bf ff 6d b 4000a118 <fastlz_decompress+0x11c>
<== NOT EXECUTED
4000a368: 80 a3 20 00 cmp %o4, 0
<== NOT EXECUTED
flzuint8 b = ref[-1];
4000a36c: c2 08 ff ff ldub [ %g3 + -1 ], %g1
*op++ = b;
4000a370: c2 28 c0 00 stb %g1, [ %g3 ]
for(; len; --len)
4000a374: 80 a7 60 00 cmp %i5, 0
*op++ = b;
4000a378: c2 28 e0 01 stb %g1, [ %g3 + 1 ]
for(; len; --len)
4000a37c: 02 80 00 0b be 4000a3a8 <fastlz_decompress+0x3ac>
4000a380: c2 28 e0 02 stb %g1, [ %g3 + 2 ]
4000a384: 86 07 00 1d add %i4, %i5, %g3
*op++ = b;
4000a388: b8 07 20 01 inc %i4
for(; len; --len)
4000a38c: 80 a7 00 03 cmp %i4, %g3
4000a390: 12 bf ff fe bne 4000a388 <fastlz_decompress+0x38c>
4000a394: c2 2f 3f ff stb %g1, [ %i4 + -1 ]
while(FASTLZ_EXPECT_CONDITIONAL(loop));
4000a398: 10 bf ff c7 b 4000a2b4 <fastlz_decompress+0x2b8>
4000a39c: 80 a3 20 00 cmp %o4, 0
for(; len; --len)
4000a3a0: 10 bf ff 5d b 4000a114 <fastlz_decompress+0x118>
<== NOT EXECUTED
4000a3a4: 82 10 00 1d mov %i5, %g1
<== NOT EXECUTED
4000a3a8: 10 bf ff c2 b 4000a2b0 <fastlz_decompress+0x2b4>
4000a3ac: 86 10 00 1c mov %i4, %g3
ofs = (*ip++) << 8;
4000a3b0: fa 0e 20 01 ldub [ %i0 + 1 ], %i5
<== NOT EXECUTED
ref = op - ofs - MAX_DISTANCE;
4000a3b4: 88 23 c0 04 sub %o7, %g4, %g4
<== NOT EXECUTED
ofs = (*ip++) << 8;
4000a3b8: bb 2f 60 08 sll %i5, 8, %i5
<== NOT EXECUTED
ofs += *ip++;
4000a3bc: 9a 06 20 03 add %i0, 3, %o5
<== NOT EXECUTED
ref = op - ofs - MAX_DISTANCE;
4000a3c0: 88 21 00 1d sub %g4, %i5, %g4
<== NOT EXECUTED
4000a3c4: 10 bf ff 33 b 4000a090 <fastlz_decompress+0x94>
<== NOT EXECUTED
4000a3c8: 88 00 40 04 add %g1, %g4, %g4
<== NOT EXECUTED
loop = 0;
4000a3cc: 10 bf ff 3e b 4000a0c4 <fastlz_decompress+0xc8>
<== NOT EXECUTED
4000a3d0: 98 10 20 00 clr %o4
<== NOT EXECUTED
4000a3d4: 10 bf ff a3 b 4000a260 <fastlz_decompress+0x264>
<== NOT EXECUTED
4000a3d8: 98 10 20 00 clr %o4
<== NOT EXECUTED
*op++ = *ip++;
4000a3dc: 10 bf ff 76 b 4000a1b4 <fastlz_decompress+0x1b8>
<== NOT EXECUTED
4000a3e0: 82 10 00 0c mov %o4, %g1
<== NOT EXECUTED
4000a3e4: 10 bf ff cf b 4000a320 <fastlz_decompress+0x324>
4000a3e8: 86 10 00 0f mov %o7, %g3
4000a4c8 <rtems_rtl_alloc_del>:
void
rtems_rtl_alloc_del (rtems_rtl_alloc_tag tag, void* address)
{
4000a4c8: 9d e3 bf a0 save %sp, -96, %sp
rtems_rtl_data* rtl = rtems_rtl_lock ();
4000a4cc: 40 00 07 da call 4000c434 <rtems_rtl_lock>
4000a4d0: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
4000a4d4: ba 10 00 08 mov %o0, %i5
if (rtems_rtl_trace (RTEMS_RTL_TRACE_ALLOCATOR))
4000a4d8: 40 00 18 4b call 40010604 <rtems_rtl_trace>
4000a4dc: 90 10 22 00 mov 0x200, %o0
4000a4e0: 80 a2 20 00 cmp %o0, 0
4000a4e4: 12 80 00 11 bne 4000a528 <rtems_rtl_alloc_del+0x60>
4000a4e8: 85 2e 20 02 sll %i0, 2, %g2
printf ("rtl: alloc: del: %s addr=%p\n",
rtems_rtl_trace_tag_label (tag), address);
if (rtl && address)
4000a4ec: c2 07 a0 48 ld [ %fp + 0x48 ], %g1
4000a4f0: 80 a0 60 00 cmp %g1, 0
4000a4f4: 02 80 00 09 be 4000a518 <rtems_rtl_alloc_del+0x50>
4000a4f8: 80 a7 60 00 cmp %i5, 0
4000a4fc: 02 80 00 07 be 4000a518 <rtems_rtl_alloc_del+0x50>
<== NEVER TAKEN
4000a500: 96 10 20 00 clr %o3
rtl->allocator.allocator (false, tag, &address, 0);
4000a504: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000a508: 94 07 a0 48 add %fp, 0x48, %o2
4000a50c: 92 10 00 18 mov %i0, %o1
4000a510: 9f c0 40 00 call %g1
4000a514: 90 10 20 00 clr %o0
rtems_rtl_unlock ();
4000a518: 40 00 08 cc call 4000c848 <rtems_rtl_unlock>
4000a51c: 01 00 00 00 nop
}
4000a520: 81 c7 e0 08 ret
4000a524: 81 e8 00 00 restore
printf ("rtl: alloc: del: %s addr=%p\n",
4000a528: d4 07 a0 48 ld [ %fp + 0x48 ], %o2
4000a52c: 03 10 00 c1 sethi %hi(0x40030400), %g1
4000a530: 82 10 62 3c or %g1, 0x23c, %g1 ! 4003063c <tag_labels>
4000a534: d2 00 40 02 ld [ %g1 + %g2 ], %o1
4000a538: 11 10 00 c1 sethi %hi(0x40030400), %o0
4000a53c: 40 00 39 03 call 40018948 <__wrap_printf>
4000a540: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 400305e0 <rtems_filesystem_null_handlers+0x68>
if (rtl && address)
4000a544: 10 bf ff eb b 4000a4f0 <rtems_rtl_alloc_del+0x28>
4000a548: c2 07 a0 48 ld [ %fp + 0x48 ], %g1
4000a5a8 <rtems_rtl_alloc_module_new>:
{
4000a5a8: 9d e3 bf a0 save %sp, -96, %sp
4000a5ac: e0 07 a0 64 ld [ %fp + 0x64 ], %l0
*text_base = *const_base = *data_base = *bss_base = NULL;
4000a5b0: c0 24 00 00 clr [ %l0 ]
if (text_size)
4000a5b4: 80 a6 60 00 cmp %i1, 0
{
4000a5b8: e2 07 a0 5c ld [ %fp + 0x5c ], %l1
*text_base = *const_base = *data_base = *bss_base = NULL;
4000a5bc: c0 24 40 00 clr [ %l1 ]
4000a5c0: c0 26 80 00 clr [ %i2 ]
if (text_size)
4000a5c4: 12 80 00 24 bne 4000a654 <rtems_rtl_alloc_module_new+0xac>
<== ALWAYS TAKEN
4000a5c8: c0 26 00 00 clr [ %i0 ]
if (const_size)
4000a5cc: 80 a6 e0 00 cmp %i3, 0
<== NOT EXECUTED
4000a5d0: 12 80 00 2d bne 4000a684 <rtems_rtl_alloc_module_new+0xdc>
<== NOT EXECUTED
4000a5d4: 94 10 20 00 clr %o2
<== NOT EXECUTED
if (eh_size)
4000a5d8: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
4000a5dc: 12 80 00 34 bne 4000a6ac <rtems_rtl_alloc_module_new+0x104>
<== NOT EXECUTED
4000a5e0: 94 10 20 00 clr %o2
<== NOT EXECUTED
if (data_size)
4000a5e4: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
<== NOT EXECUTED
4000a5e8: 80 a0 60 00 cmp %g1, 0
4000a5ec: 12 80 00 3b bne 4000a6d8 <rtems_rtl_alloc_module_new+0x130>
<== NEVER TAKEN
4000a5f0: 94 10 20 00 clr %o2
if (bss_size)
4000a5f4: c2 07 a0 68 ld [ %fp + 0x68 ], %g1
4000a5f8: 80 a0 60 00 cmp %g1, 0
4000a5fc: 12 80 00 06 bne 4000a614 <rtems_rtl_alloc_module_new+0x6c>
<== NEVER TAKEN
4000a600: d2 07 a0 68 ld [ %fp + 0x68 ], %o1
return true;
4000a604: 82 10 20 01 mov 1, %g1
}
4000a608: b0 08 60 01 and %g1, 1, %i0
4000a60c: 81 c7 e0 08 ret
4000a610: 81 e8 00 00 restore
*bss_base = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_READ_WRITE,
4000a614: 94 10 20 00 clr %o2
<== NOT EXECUTED
4000a618: 7f ff ff 83 call 4000a424 <rtems_rtl_alloc_new>
<== NOT EXECUTED
4000a61c: 90 10 20 04 mov 4, %o0
<== NOT EXECUTED
if (!*bss_base)
4000a620: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000a624: 12 bf ff f8 bne 4000a604 <rtems_rtl_alloc_module_new+0x5c>
<== NOT EXECUTED
4000a628: d0 24 00 00 st %o0, [ %l0 ]
<== NOT EXECUTED
rtems_rtl_alloc_module_del (text_base, const_base, eh_base,
4000a62c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000a630: 98 10 00 10 mov %l0, %o4
<== NOT EXECUTED
4000a634: 96 10 00 11 mov %l1, %o3
<== NOT EXECUTED
4000a638: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
4000a63c: 7f ff ff c4 call 4000a54c <rtems_rtl_alloc_module_del>
<== NOT EXECUTED
4000a640: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
return false;
4000a644: 82 10 20 00 clr %g1
<== NOT EXECUTED
}
4000a648: b0 08 60 01 and %g1, 1, %i0
<== NOT EXECUTED
4000a64c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000a650: 81 e8 00 00 restore
<== NOT EXECUTED
*text_base = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_READ_EXEC,
4000a654: 94 10 20 00 clr %o2
4000a658: 92 10 00 19 mov %i1, %o1
4000a65c: 7f ff ff 72 call 4000a424 <rtems_rtl_alloc_new>
4000a660: 90 10 20 05 mov 5, %o0
4000a664: d0 26 00 00 st %o0, [ %i0 ]
if (!*text_base)
4000a668: 80 a2 20 00 cmp %o0, 0
4000a66c: 02 bf ff e7 be 4000a608 <rtems_rtl_alloc_module_new+0x60>
<== NEVER TAKEN
4000a670: 82 10 20 00 clr %g1
if (const_size)
4000a674: 80 a6 e0 00 cmp %i3, 0
4000a678: 02 bf ff d9 be 4000a5dc <rtems_rtl_alloc_module_new+0x34>
<== NEVER TAKEN
4000a67c: 80 a7 60 00 cmp %i5, 0
*const_base = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_READ,
4000a680: 94 10 20 00 clr %o2
4000a684: 92 10 00 1b mov %i3, %o1
4000a688: 7f ff ff 67 call 4000a424 <rtems_rtl_alloc_new>
4000a68c: 90 10 20 03 mov 3, %o0
if (!*const_base)
4000a690: 80 a2 20 00 cmp %o0, 0
4000a694: 02 bf ff e6 be 4000a62c <rtems_rtl_alloc_module_new+0x84>
<== NEVER TAKEN
4000a698: d0 26 80 00 st %o0, [ %i2 ]
if (eh_size)
4000a69c: 80 a7 60 00 cmp %i5, 0
4000a6a0: 02 bf ff d2 be 4000a5e8 <rtems_rtl_alloc_module_new+0x40>
4000a6a4: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
*eh_base = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_READ,
4000a6a8: 94 10 20 00 clr %o2
4000a6ac: 92 10 00 1d mov %i5, %o1
4000a6b0: 7f ff ff 5d call 4000a424 <rtems_rtl_alloc_new>
4000a6b4: 90 10 20 03 mov 3, %o0
if (!*eh_base)
4000a6b8: 80 a2 20 00 cmp %o0, 0
4000a6bc: 02 bf ff dc be 4000a62c <rtems_rtl_alloc_module_new+0x84>
<== NEVER TAKEN
4000a6c0: d0 27 00 00 st %o0, [ %i4 ]
if (data_size)
4000a6c4: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
4000a6c8: 80 a0 60 00 cmp %g1, 0
4000a6cc: 22 bf ff cb be,a 4000a5f8 <rtems_rtl_alloc_module_new+0x50>
<== ALWAYS TAKEN
4000a6d0: c2 07 a0 68 ld [ %fp + 0x68 ], %g1
*data_base = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_READ_WRITE,
4000a6d4: 94 10 20 00 clr %o2
<== NOT EXECUTED
4000a6d8: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
4000a6dc: 7f ff ff 52 call 4000a424 <rtems_rtl_alloc_new>
<== NOT EXECUTED
4000a6e0: 90 10 20 04 mov 4, %o0
<== NOT EXECUTED
if (!*data_base)
4000a6e4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000a6e8: 12 bf ff c3 bne 4000a5f4 <rtems_rtl_alloc_module_new+0x4c>
<== NOT EXECUTED
4000a6ec: d0 24 40 00 st %o0, [ %l1 ]
<== NOT EXECUTED
4000a6f0: 10 bf ff d0 b 4000a630 <rtems_rtl_alloc_module_new+0x88>
<== NOT EXECUTED
4000a6f4: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000a424 <rtems_rtl_alloc_new>:
void*
rtems_rtl_alloc_new (rtems_rtl_alloc_tag tag, size_t size, bool zero)
{
4000a424: 9d e3 bf 98 save %sp, -104, %sp
rtems_rtl_data* rtl = rtems_rtl_lock ();
4000a428: 40 00 08 03 call 4000c434 <rtems_rtl_lock>
4000a42c: 01 00 00 00 nop
/*
* Obtain memory from the allocator. The address field is set by the
* allocator.
*/
if (rtl)
4000a430: 80 a2 20 00 cmp %o0, 0
4000a434: 02 80 00 08 be 4000a454 <rtems_rtl_alloc_new+0x30>
<== NEVER TAKEN
4000a438: c0 27 bf fc clr [ %fp + -4 ]
rtl->allocator.allocator (true, tag, &address, size);
4000a43c: c2 02 20 18 ld [ %o0 + 0x18 ], %g1
4000a440: 96 10 00 19 mov %i1, %o3
4000a444: 94 07 bf fc add %fp, -4, %o2
4000a448: 92 10 00 18 mov %i0, %o1
4000a44c: 9f c0 40 00 call %g1
4000a450: 90 10 20 01 mov 1, %o0
rtems_rtl_unlock ();
4000a454: 40 00 08 fd call 4000c848 <rtems_rtl_unlock>
4000a458: 01 00 00 00 nop
if (rtems_rtl_trace (RTEMS_RTL_TRACE_ALLOCATOR))
4000a45c: 40 00 18 6a call 40010604 <rtems_rtl_trace>
4000a460: 90 10 22 00 mov 0x200, %o0 ! 200 <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0xb0>
4000a464: 80 a2 20 00 cmp %o0, 0
4000a468: 12 80 00 0e bne 4000a4a0 <rtems_rtl_alloc_new+0x7c>
4000a46c: b1 2e 20 02 sll %i0, 2, %i0
rtems_rtl_trace_tag_label (tag), address, size);
/*
* Only zero the memory if asked to and the allocation was successful.
*/
if (address && zero)
4000a470: f0 07 bf fc ld [ %fp + -4 ], %i0
4000a474: 80 a6 20 00 cmp %i0, 0
4000a478: 02 80 00 08 be 4000a498 <rtems_rtl_alloc_new+0x74>
4000a47c: 80 a6 a0 00 cmp %i2, 0
4000a480: 02 80 00 06 be 4000a498 <rtems_rtl_alloc_new+0x74>
4000a484: 90 10 00 18 mov %i0, %o0
memset (address, 0, size);
4000a488: 94 10 00 19 mov %i1, %o2
4000a48c: 40 00 42 c0 call 4001af8c <memset>
4000a490: 92 10 20 00 clr %o1
4000a494: f0 07 bf fc ld [ %fp + -4 ], %i0
return address;
}
4000a498: 81 c7 e0 08 ret
4000a49c: 81 e8 00 00 restore
printf ("rtl: alloc: new: %s addr=%p size=%zu\n",
4000a4a0: d4 07 bf fc ld [ %fp + -4 ], %o2
4000a4a4: 03 10 00 c1 sethi %hi(0x40030400), %g1
4000a4a8: 82 10 62 3c or %g1, 0x23c, %g1 ! 4003063c <tag_labels>
4000a4ac: d2 00 40 18 ld [ %g1 + %i0 ], %o1
4000a4b0: 96 10 00 19 mov %i1, %o3
4000a4b4: 11 10 00 c1 sethi %hi(0x40030400), %o0
4000a4b8: 40 00 39 24 call 40018948 <__wrap_printf>
4000a4bc: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 400305b8 <rtems_filesystem_null_handlers+0x40>
if (address && zero)
4000a4c0: 10 bf ff ed b 4000a474 <rtems_rtl_alloc_new+0x50>
4000a4c4: f0 07 bf fc ld [ %fp + -4 ], %i0
4000cbd8 <rtems_rtl_base_sym_global_add>:
}
void
rtems_rtl_base_sym_global_add (const unsigned char* esyms,
unsigned int size)
{
4000cbd8: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rtl_trace (RTEMS_RTL_TRACE_GLOBAL_SYM))
4000cbdc: 40 00 0e 8a call 40010604 <rtems_rtl_trace>
4000cbe0: 90 10 20 80 mov 0x80, %o0
4000cbe4: 80 a2 20 00 cmp %o0, 0
4000cbe8: 12 80 00 10 bne 4000cc28 <rtems_rtl_base_sym_global_add+0x50>
4000cbec: 92 10 00 19 mov %i1, %o1
printf ("rtl: adding global symbols, table size %u\n", size);
if (!rtems_rtl_lock ())
4000cbf0: 7f ff fe 11 call 4000c434 <rtems_rtl_lock>
4000cbf4: 01 00 00 00 nop
4000cbf8: 80 a2 20 00 cmp %o0, 0
4000cbfc: 22 80 00 14 be,a 4000cc4c <rtems_rtl_base_sym_global_add+0x74>
<== NEVER TAKEN
4000cc00: 33 10 00 c3 sethi %hi(0x40030c00), %i1
<== NOT EXECUTED
{
rtems_rtl_set_error (EINVAL, "global add cannot lock rtl");
return;
}
rtems_rtl_symbol_global_add (rtl->base, esyms, size);
4000cc04: 3b 10 00 d8 sethi %hi(0x40036000), %i5
4000cc08: c2 07 61 e4 ld [ %i5 + 0x1e4 ], %g1 ! 400361e4 <rtl>
4000cc0c: d0 00 60 90 ld [ %g1 + 0x90 ], %o0
4000cc10: 92 10 00 18 mov %i0, %o1
4000cc14: 40 00 0d 6d call 400101c8 <rtems_rtl_symbol_global_add>
4000cc18: 94 10 00 19 mov %i1, %o2
4000cc1c: f0 07 61 e4 ld [ %i5 + 0x1e4 ], %i0
<== NOT EXECUTED
4000cc20: 40 00 1e 80 call 40014620 <_Mutex_recursive_Release>
<== NOT EXECUTED
4000cc24: 81 e8 00 00 restore
printf ("rtl: adding global symbols, table size %u\n", size);
4000cc28: 11 10 00 c3 sethi %hi(0x40030c00), %o0
4000cc2c: 40 00 2f 47 call 40018948 <__wrap_printf>
4000cc30: 90 12 22 60 or %o0, 0x260, %o0 ! 40030e60 <reloc_target_flags+0xf8>
if (!rtems_rtl_lock ())
4000cc34: 7f ff fe 00 call 4000c434 <rtems_rtl_lock>
4000cc38: 01 00 00 00 nop
4000cc3c: 80 a2 20 00 cmp %o0, 0
4000cc40: 12 bf ff f2 bne 4000cc08 <rtems_rtl_base_sym_global_add+0x30>
<== ALWAYS TAKEN
4000cc44: 3b 10 00 d8 sethi %hi(0x40036000), %i5
rtems_rtl_set_error (EINVAL, "global add cannot lock rtl");
4000cc48: 33 10 00 c3 sethi %hi(0x40030c00), %i1
<== NOT EXECUTED
4000cc4c: b0 10 20 16 mov 0x16, %i0
<== NOT EXECUTED
4000cc50: 7f ff fc 67 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000cc54: 93 ee 62 90 restore %i1, 0x290, %o1
<== NOT EXECUTED
4000cc58 <rtems_rtl_baseimage>:
rtems_rtl_obj*
rtems_rtl_baseimage (void)
{
return NULL;
}
4000cc58: 81 c3 e0 08 retl
<== NOT EXECUTED
4000cc5c: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000c85c <rtems_rtl_check_handle>:
node = rtems_chain_first (&rtl->objects);
4000c85c: 03 10 00 d8 sethi %hi(0x40036000), %g1
4000c860: c4 00 61 e4 ld [ %g1 + 0x1e4 ], %g2 ! 400361e4 <rtl>
return _Chain_Immutable_head( the_chain )->next;
4000c864: c2 00 a0 64 ld [ %g2 + 0x64 ], %g1
return &the_chain->Tail.Node;
4000c868: 84 00 a0 68 add %g2, 0x68, %g2
while (!rtems_chain_is_tail (&rtl->objects, node))
4000c86c: 80 a0 40 02 cmp %g1, %g2
4000c870: 12 80 00 07 bne 4000c88c <rtems_rtl_check_handle+0x30>
<== ALWAYS TAKEN
4000c874: 80 a2 00 01 cmp %o0, %g1
return NULL;
4000c878: 10 80 00 0a b 4000c8a0 <rtems_rtl_check_handle+0x44>
<== NOT EXECUTED
4000c87c: 82 10 20 00 clr %g1
<== NOT EXECUTED
while (!rtems_chain_is_tail (&rtl->objects, node))
4000c880: 80 a0 40 02 cmp %g1, %g2
4000c884: 02 80 00 06 be 4000c89c <rtems_rtl_check_handle+0x40>
<== NEVER TAKEN
4000c888: 80 a2 00 01 cmp %o0, %g1
if (check == obj)
4000c88c: 32 bf ff fd bne,a 4000c880 <rtems_rtl_check_handle+0x24>
4000c890: c2 00 40 00 ld [ %g1 ], %g1
}
4000c894: 81 c3 e0 08 retl
4000c898: 90 10 00 01 mov %g1, %o0
return NULL;
4000c89c: 82 10 20 00 clr %g1
<== NOT EXECUTED
}
4000c8a0: 81 c3 e0 08 retl
<== NOT EXECUTED
4000c8a4: 90 10 00 01 mov %g1, %o0
<== NOT EXECUTED
4000b5cc <rtems_rtl_elf_file_check>:
return true;
}
bool
rtems_rtl_elf_file_check (rtems_rtl_obj* obj, int fd)
{
4000b5cc: 9d e3 bf 68 save %sp, -152, %sp
rtems_rtl_obj_cache* header;
Elf_Ehdr ehdr;
rtems_rtl_obj_caches (&header, NULL, NULL);
4000b5d0: 94 10 20 00 clr %o2
4000b5d4: 92 10 20 00 clr %o1
4000b5d8: 40 00 03 5f call 4000c354 <rtems_rtl_obj_caches>
4000b5dc: 90 07 bf c8 add %fp, -56, %o0
if (!rtems_rtl_obj_cache_read_byval (header, fd, obj->ooffset,
4000b5e0: d4 1e 20 20 ldd [ %i0 + 0x20 ], %o2
4000b5e4: d0 07 bf c8 ld [ %fp + -56 ], %o0
4000b5e8: 9a 10 20 34 mov 0x34, %o5
4000b5ec: 98 07 bf cc add %fp, -52, %o4
4000b5f0: 40 00 07 14 call 4000d240 <rtems_rtl_obj_cache_read_byval>
4000b5f4: 92 10 00 19 mov %i1, %o1
4000b5f8: 80 a2 20 00 cmp %o0, 0
4000b5fc: 02 80 00 0c be 4000b62c <rtems_rtl_elf_file_check+0x60>
<== NEVER TAKEN
4000b600: b0 10 00 08 mov %o0, %i0
return false;
/*
* Check we have a valid ELF file.
*/
if ((memcmp (ELFMAG, ehdr.e_ident, SELFMAG) != 0)
4000b604: c4 07 bf cc ld [ %fp + -52 ], %g2
4000b608: 03 1f d1 53 sethi %hi(0x7f454c00), %g1
4000b60c: 82 10 60 46 or %g1, 0x46, %g1 ! 7f454c46 <RAM_END+0x3f054c46>
4000b610: 80 a0 80 01 cmp %g2, %g1
4000b614: 12 80 00 06 bne 4000b62c <rtems_rtl_elf_file_check+0x60>
<== NEVER TAKEN
4000b618: b0 10 20 00 clr %i0
|| ehdr.e_ident[EI_CLASS] != ELFCLASS)
4000b61c: c2 0f bf d0 ldub [ %fp + -48 ], %g1
4000b620: 80 a0 60 01 cmp %g1, 1
4000b624: 02 80 00 05 be 4000b638 <rtems_rtl_elf_file_check+0x6c>
<== ALWAYS TAKEN
4000b628: c2 0f bf d2 ldub [ %fp + -46 ], %g1
{
return false;
}
return true;
}
4000b62c: b0 0e 20 ff and %i0, 0xff, %i0
4000b630: 81 c7 e0 08 ret
4000b634: 81 e8 00 00 restore
if ((ehdr.e_ident[EI_VERSION] != EV_CURRENT)
4000b638: 80 a0 60 01 cmp %g1, 1
4000b63c: 32 bf ff fd bne,a 4000b630 <rtems_rtl_elf_file_check+0x64>
<== NEVER TAKEN
4000b640: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
|| (ehdr.e_version != EV_CURRENT)
4000b644: c2 07 bf e0 ld [ %fp + -32 ], %g1
4000b648: 80 a0 60 01 cmp %g1, 1
4000b64c: 32 bf ff f9 bne,a 4000b630 <rtems_rtl_elf_file_check+0x64>
<== NEVER TAKEN
4000b650: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
|| (ehdr.e_ident[EI_DATA] != ELFDEFNNAME (MACHDEP_ENDIANNESS)))
4000b654: c2 0f bf d1 ldub [ %fp + -47 ], %g1
4000b658: 82 18 60 02 xor %g1, 2, %g1
4000b65c: 80 a0 00 01 cmp %g0, %g1
4000b660: 10 bf ff f3 b 4000b62c <rtems_rtl_elf_file_check+0x60>
4000b664: b0 60 3f ff subx %g0, -1, %i0
4000b690 <rtems_rtl_elf_file_load>:
return true;
}
bool
rtems_rtl_elf_file_load (rtems_rtl_obj* obj, int fd)
{
4000b690: 9d e3 bf 20 save %sp, -224, %sp
rtems_rtl_obj_cache* header;
Elf_Ehdr ehdr;
rtems_rtl_obj_caches (&header, NULL, NULL);
4000b694: 94 10 20 00 clr %o2
4000b698: 92 10 20 00 clr %o1
4000b69c: 40 00 03 2e call 4000c354 <rtems_rtl_obj_caches>
4000b6a0: 90 07 bf 90 add %fp, -112, %o0
if (!rtems_rtl_obj_cache_read_byval (header, fd, obj->ooffset,
4000b6a4: d0 07 bf 90 ld [ %fp + -112 ], %o0
4000b6a8: d4 1e 20 20 ldd [ %i0 + 0x20 ], %o2
4000b6ac: 9a 10 20 34 mov 0x34, %o5
4000b6b0: 98 07 bf cc add %fp, -52, %o4
4000b6b4: 40 00 06 e3 call 4000d240 <rtems_rtl_obj_cache_read_byval>
4000b6b8: 92 10 00 19 mov %i1, %o1
4000b6bc: 80 a2 20 00 cmp %o0, 0
4000b6c0: 02 80 00 2f be 4000b77c <rtems_rtl_elf_file_load+0xec>
<== NEVER TAKEN
4000b6c4: c4 07 bf cc ld [ %fp + -52 ], %g2
return false;
/*
* Check we have a valid ELF file.
*/
if ((memcmp (ELFMAG, ehdr.e_ident, SELFMAG) != 0)
4000b6c8: 03 1f d1 53 sethi %hi(0x7f454c00), %g1
4000b6cc: 82 10 60 46 or %g1, 0x46, %g1 ! 7f454c46 <RAM_END+0x3f054c46>
4000b6d0: 80 a0 80 01 cmp %g2, %g1
4000b6d4: 12 80 00 05 bne 4000b6e8 <rtems_rtl_elf_file_load+0x58>
<== NEVER TAKEN
4000b6d8: c2 0f bf d0 ldub [ %fp + -48 ], %g1
|| ehdr.e_ident[EI_CLASS] != ELFCLASS)
4000b6dc: 80 a0 60 01 cmp %g1, 1
4000b6e0: 02 80 00 0a be 4000b708 <rtems_rtl_elf_file_load+0x78>
<== ALWAYS TAKEN
4000b6e4: c2 0f bf d2 ldub [ %fp + -46 ], %g1
{
rtems_rtl_set_error (EINVAL, "invalid ELF file format");
4000b6e8: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
4000b6ec: 13 10 00 c2 sethi %hi(0x40030800), %o1
<== NOT EXECUTED
return false;
4000b6f0: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "invalid ELF file format");
4000b6f4: 40 00 01 be call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000b6f8: 92 12 60 f0 or %o1, 0xf0, %o1
<== NOT EXECUTED
4000b6fc: b0 0e 20 ff and %i0, 0xff, %i0
{
return false;
}
return true;
}
4000b700: 81 c7 e0 08 ret
4000b704: 81 e8 00 00 restore
if ((ehdr.e_ident[EI_VERSION] != EV_CURRENT)
4000b708: 80 a0 60 01 cmp %g1, 1
4000b70c: 12 80 00 20 bne 4000b78c <rtems_rtl_elf_file_load+0xfc>
<== NEVER TAKEN
4000b710: c2 07 bf e0 ld [ %fp + -32 ], %g1
|| (ehdr.e_version != EV_CURRENT)
4000b714: 80 a0 60 01 cmp %g1, 1
4000b718: 12 80 00 1e bne 4000b790 <rtems_rtl_elf_file_load+0x100>
<== NEVER TAKEN
4000b71c: 90 10 20 16 mov 0x16, %o0
|| (ehdr.e_ident[EI_DATA] != ELFDEFNNAME (MACHDEP_ENDIANNESS)))
4000b720: c2 0f bf d1 ldub [ %fp + -47 ], %g1
4000b724: 80 a0 60 02 cmp %g1, 2
4000b728: 12 80 00 1b bne 4000b794 <rtems_rtl_elf_file_load+0x104>
<== NEVER TAKEN
4000b72c: 13 10 00 c2 sethi %hi(0x40030800), %o1
switch (ehdr->e_machine)
4000b730: c2 17 bf de lduh [ %fp + -34 ], %g1
4000b734: 80 a0 60 02 cmp %g1, 2
4000b738: 02 80 00 04 be 4000b748 <rtems_rtl_elf_file_load+0xb8>
<== ALWAYS TAKEN
4000b73c: 80 a0 60 12 cmp %g1, 0x12
4000b740: 12 80 00 1b bne 4000b7ac <rtems_rtl_elf_file_load+0x11c>
<== NOT EXECUTED
4000b744: 13 10 00 c2 sethi %hi(0x40030800), %o1
<== NOT EXECUTED
if (ehdr.e_type == ET_DYN)
4000b748: c2 17 bf dc lduh [ %fp + -36 ], %g1
4000b74c: 80 a0 60 03 cmp %g1, 3
4000b750: 02 80 00 f8 be 4000bb30 <rtems_rtl_elf_file_load+0x4a0>
<== NEVER TAKEN
4000b754: c2 17 bf f6 lduh [ %fp + -10 ], %g1
if (ehdr.e_phentsize != 0)
4000b758: 80 a0 60 00 cmp %g1, 0
4000b75c: 12 80 00 1a bne 4000b7c4 <rtems_rtl_elf_file_load+0x134>
<== NEVER TAKEN
4000b760: c2 17 bf fa lduh [ %fp + -6 ], %g1
if (ehdr.e_shentsize != sizeof (Elf_Shdr))
4000b764: 80 a0 60 28 cmp %g1, 0x28
4000b768: 02 80 00 1f be 4000b7e4 <rtems_rtl_elf_file_load+0x154>
<== ALWAYS TAKEN
4000b76c: 13 10 00 c2 sethi %hi(0x40030800), %o1
rtems_rtl_set_error (EINVAL, "invalid ELF section header size");
4000b770: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
4000b774: 40 00 01 9e call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000b778: 92 12 61 90 or %o1, 0x190, %o1
<== NOT EXECUTED
return false;
4000b77c: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000b780: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
}
4000b784: 81 c7 e0 08 ret
<== NOT EXECUTED
4000b788: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "unsupported ELF file version");
4000b78c: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
4000b790: 13 10 00 c2 sethi %hi(0x40030800), %o1
<== NOT EXECUTED
return false;
4000b794: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "unsupported ELF file version");
4000b798: 92 12 61 08 or %o1, 0x108, %o1
<== NOT EXECUTED
4000b79c: 40 00 01 94 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000b7a0: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
}
4000b7a4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000b7a8: 81 e8 00 00 restore
<== NOT EXECUTED
return false;
4000b7ac: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "unsupported machine type");
4000b7b0: 40 00 01 8f call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000b7b4: 92 12 61 28 or %o1, 0x128, %o1
<== NOT EXECUTED
4000b7b8: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
4000b7bc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000b7c0: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "ELF file contains program headers");
4000b7c4: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
4000b7c8: 13 10 00 c2 sethi %hi(0x40030800), %o1
<== NOT EXECUTED
return false;
4000b7cc: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "ELF file contains program headers");
4000b7d0: 40 00 01 87 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000b7d4: 92 12 61 68 or %o1, 0x168, %o1
<== NOT EXECUTED
4000b7d8: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
4000b7dc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000b7e0: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rtl_obj_caches (§s, &strings, NULL);
4000b7e4: 90 07 bf 94 add %fp, -108, %o0
4000b7e8: 94 10 20 00 clr %o2
4000b7ec: 40 00 02 da call 4000c354 <rtems_rtl_obj_caches>
4000b7f0: 92 07 bf 98 add %fp, -104, %o1
if (!sects || !strings)
4000b7f4: d0 07 bf 94 ld [ %fp + -108 ], %o0
4000b7f8: 80 a2 20 00 cmp %o0, 0
4000b7fc: 02 bf ff e0 be 4000b77c <rtems_rtl_elf_file_load+0xec>
<== NEVER TAKEN
4000b800: c2 07 bf 98 ld [ %fp + -104 ], %g1
4000b804: 80 a0 60 00 cmp %g1, 0
4000b808: 02 bf ff dd be 4000b77c <rtems_rtl_elf_file_load+0xec>
<== NEVER TAKEN
4000b80c: fa 07 bf ec ld [ %fp + -20 ], %i5
off = obj->ooffset + ehdr->e_shoff + (ehdr->e_shstrndx * ehdr->e_shentsize);
4000b810: c4 1e 20 20 ldd [ %i0 + 0x20 ], %g2
4000b814: c2 17 bf fe lduh [ %fp + -2 ], %g1
4000b818: c8 17 bf fa lduh [ %fp + -6 ], %g4
4000b81c: 96 80 c0 1d addcc %g3, %i5, %o3
4000b820: 82 58 40 04 smul %g1, %g4, %g1
4000b824: 94 40 a0 00 addx %g2, 0, %o2
if (!rtems_rtl_obj_cache_read_byval (sects, fd, off, &shdr, sizeof (shdr)))
4000b828: ba 82 c0 01 addcc %o3, %g1, %i5
off = obj->ooffset + ehdr->e_shoff + (ehdr->e_shstrndx * ehdr->e_shentsize);
4000b82c: 85 38 60 1f sra %g1, 0x1f, %g2
if (!rtems_rtl_obj_cache_read_byval (sects, fd, off, &shdr, sizeof (shdr)))
4000b830: 96 10 00 1d mov %i5, %o3
4000b834: b8 42 80 02 addx %o2, %g2, %i4
4000b838: 9a 10 20 28 mov 0x28, %o5
4000b83c: 94 10 00 1c mov %i4, %o2
4000b840: 98 07 bf a4 add %fp, -92, %o4
4000b844: 40 00 06 7f call 4000d240 <rtems_rtl_obj_cache_read_byval>
4000b848: 92 10 00 19 mov %i1, %o1
4000b84c: 80 a2 20 00 cmp %o0, 0
4000b850: 02 bf ff cb be 4000b77c <rtems_rtl_elf_file_load+0xec>
<== NEVER TAKEN
4000b854: c2 07 bf a8 ld [ %fp + -88 ], %g1
if (shdr.sh_type != SHT_STRTAB)
4000b858: 80 a0 60 03 cmp %g1, 3
4000b85c: 12 80 01 31 bne 4000bd20 <rtems_rtl_elf_file_load+0x690>
<== NEVER TAKEN
4000b860: c2 07 bf b4 ld [ %fp + -76 ], %g1
sectstroff = obj->ooffset + shdr.sh_offset;
4000b864: c4 1e 20 20 ldd [ %i0 + 0x20 ], %g2
4000b868: a2 80 c0 01 addcc %g3, %g1, %l1
for (section = 0; section < ehdr->e_shnum; ++section)
4000b86c: c2 17 bf fc lduh [ %fp + -4 ], %g1
sectstroff = obj->ooffset + shdr.sh_offset;
4000b870: a0 40 a0 00 addx %g2, 0, %l0
for (section = 0; section < ehdr->e_shnum; ++section)
4000b874: 80 a0 60 00 cmp %g1, 0
4000b878: 02 80 00 b6 be 4000bb50 <rtems_rtl_elf_file_load+0x4c0>
<== NEVER TAKEN
4000b87c: 2d 10 00 c2 sethi %hi(0x40030800), %l6
printf ("rtl: section: %2d: type=%d flags=%08x link=%d info=%d\n",
4000b880: 2b 10 00 c2 sethi %hi(0x40030800), %l5
if (strcmp (".ctors", name) == 0)
4000b884: 29 10 00 c2 sethi %hi(0x40030800), %l4
if (strcmp (".dtors", name) == 0)
4000b888: 35 10 00 c2 sethi %hi(0x40030800), %i2
switch (shdr.sh_type)
4000b88c: 37 10 00 2d sethi %hi(0x4000b400), %i3
for (section = 0; section < ehdr->e_shnum; ++section)
4000b890: b8 10 20 00 clr %i4
printf ("rtl: section header: %2d: offset=%d\n", section, (int) off);
4000b894: ac 15 a1 d0 or %l6, 0x1d0, %l6
printf ("rtl: section: %2d: type=%d flags=%08x link=%d info=%d\n",
4000b898: aa 15 61 f8 or %l5, 0x1f8, %l5
if (strcmp (".ctors", name) == 0)
4000b89c: a8 15 22 68 or %l4, 0x268, %l4
if (strcmp (".dtors", name) == 0)
4000b8a0: b4 16 a2 70 or %i2, 0x270, %i2
switch (shdr.sh_type)
4000b8a4: b6 16 e2 68 or %i3, 0x268, %i3
off = obj->ooffset + ehdr->e_shoff + (((uint32_t) section) * ehdr->e_shentsize);
4000b8a8: c2 17 bf fa lduh [ %fp + -6 ], %g1
4000b8ac: c8 07 bf ec ld [ %fp + -20 ], %g4
4000b8b0: 9a 80 c0 04 addcc %g3, %g4, %o5
4000b8b4: 82 58 40 1c smul %g1, %i4, %g1
4000b8b8: 98 40 a0 00 addx %g2, 0, %o4
4000b8bc: a6 83 40 01 addcc %o5, %g1, %l3
if (rtems_rtl_trace (RTEMS_RTL_TRACE_DETAIL))
4000b8c0: 90 10 20 01 mov 1, %o0
4000b8c4: 40 00 13 50 call 40010604 <rtems_rtl_trace>
4000b8c8: a4 43 20 00 addx %o4, 0, %l2
4000b8cc: 80 a2 20 00 cmp %o0, 0
4000b8d0: 02 80 00 07 be 4000b8ec <rtems_rtl_elf_file_load+0x25c>
4000b8d4: d0 07 bf 94 ld [ %fp + -108 ], %o0
printf ("rtl: section header: %2d: offset=%d\n", section, (int) off);
4000b8d8: 94 10 00 13 mov %l3, %o2
4000b8dc: 92 10 00 1c mov %i4, %o1
4000b8e0: 40 00 34 1a call 40018948 <__wrap_printf>
4000b8e4: 90 10 00 16 mov %l6, %o0
if (!rtems_rtl_obj_cache_read_byval (sects, fd, off, &shdr, sizeof (shdr)))
4000b8e8: d0 07 bf 94 ld [ %fp + -108 ], %o0
4000b8ec: 9a 10 20 28 mov 0x28, %o5
4000b8f0: 98 07 bf a4 add %fp, -92, %o4
4000b8f4: 94 10 00 12 mov %l2, %o2
4000b8f8: 96 10 00 13 mov %l3, %o3
4000b8fc: 40 00 06 51 call 4000d240 <rtems_rtl_obj_cache_read_byval>
4000b900: 92 10 00 19 mov %i1, %o1
4000b904: 80 a2 20 00 cmp %o0, 0
4000b908: 22 bf ff 9e be,a 4000b780 <rtems_rtl_elf_file_load+0xf0>
<== NEVER TAKEN
4000b90c: b0 10 20 00 clr %i0
<== NOT EXECUTED
if (rtems_rtl_trace (RTEMS_RTL_TRACE_DETAIL))
4000b910: 40 00 13 3d call 40010604 <rtems_rtl_trace>
4000b914: 90 10 20 01 mov 1, %o0
4000b918: 80 a2 20 00 cmp %o0, 0
4000b91c: 02 80 00 0a be 4000b944 <rtems_rtl_elf_file_load+0x2b4>
4000b920: c2 07 bf a8 ld [ %fp + -88 ], %g1
printf ("rtl: section: %2d: type=%d flags=%08x link=%d info=%d\n",
4000b924: da 07 bf c0 ld [ %fp + -64 ], %o5
4000b928: d8 07 bf bc ld [ %fp + -68 ], %o4
4000b92c: d6 07 bf ac ld [ %fp + -84 ], %o3
4000b930: d4 07 bf a8 ld [ %fp + -88 ], %o2
4000b934: 92 10 00 1c mov %i4, %o1
4000b938: 40 00 34 04 call 40018948 <__wrap_printf>
4000b93c: 90 10 00 15 mov %l5, %o0
switch (shdr.sh_type)
4000b940: c2 07 bf a8 ld [ %fp + -88 ], %g1
4000b944: 80 a0 60 09 cmp %g1, 9
4000b948: 18 80 00 05 bgu 4000b95c <rtems_rtl_elf_file_load+0x2cc>
4000b94c: 83 28 60 02 sll %g1, 2, %g1
4000b950: c2 06 c0 01 ld [ %i3 + %g1 ], %g1
4000b954: 81 c0 40 00 jmp %g1
4000b958: 01 00 00 00 nop
flags = rtems_rtl_elf_section_flags (obj, &shdr);
4000b95c: 92 07 bf a4 add %fp, -92, %o1
4000b960: 40 00 01 c5 call 4000c074 <rtems_rtl_elf_section_flags>
4000b964: 90 10 00 18 mov %i0, %o0
4000b968: c2 07 bf ac ld [ %fp + -84 ], %g1
if (flags == 0)
4000b96c: 80 a2 20 00 cmp %o0, 0
4000b970: 12 80 00 16 bne 4000b9c8 <rtems_rtl_elf_file_load+0x338>
<== NEVER TAKEN
4000b974: ba 10 00 08 mov %o0, %i5
if (rtems_rtl_trace (RTEMS_RTL_TRACE_WARNING))
4000b978: 40 00 13 23 call 40010604 <rtems_rtl_trace>
4000b97c: 90 10 20 02 mov 2, %o0
4000b980: 80 a2 20 00 cmp %o0, 0
4000b984: 02 80 00 09 be 4000b9a8 <rtems_rtl_elf_file_load+0x318>
<== NEVER TAKEN
4000b988: c2 17 bf fc lduh [ %fp + -4 ], %g1
printf ("rtl: unsupported section: %2d: type=%02d flags=%02x\n",
4000b98c: d6 07 bf ac ld [ %fp + -84 ], %o3
4000b990: d4 07 bf a8 ld [ %fp + -88 ], %o2
4000b994: 11 10 00 c2 sethi %hi(0x40030800), %o0
4000b998: 92 10 00 1c mov %i4, %o1
4000b99c: 40 00 33 eb call 40018948 <__wrap_printf>
4000b9a0: 90 12 22 30 or %o0, 0x230, %o0
for (section = 0; section < ehdr->e_shnum; ++section)
4000b9a4: c2 17 bf fc lduh [ %fp + -4 ], %g1
4000b9a8: b8 07 20 01 inc %i4
4000b9ac: 80 a7 00 01 cmp %i4, %g1
4000b9b0: 16 80 00 69 bge 4000bb54 <rtems_rtl_elf_file_load+0x4c4>
4000b9b4: c2 07 bf e4 ld [ %fp + -28 ], %g1
4000b9b8: 10 bf ff bc b 4000b8a8 <rtems_rtl_elf_file_load+0x218>
4000b9bc: c4 1e 20 20 ldd [ %i0 + 0x20 ], %g2
4000b9c0: c2 07 bf ac ld [ %fp + -84 ], %g1
<== NOT EXECUTED
flags = RTEMS_RTL_OBJ_SECT_REL;
4000b9c4: ba 10 20 20 mov 0x20, %i5
<== NOT EXECUTED
if ((shdr.sh_flags & SHF_LINK_ORDER) != 0)
4000b9c8: 80 88 60 80 btst 0x80, %g1
4000b9cc: 02 80 00 04 be 4000b9dc <rtems_rtl_elf_file_load+0x34c>
<== ALWAYS TAKEN
4000b9d0: d4 07 bf a4 ld [ %fp + -92 ], %o2
flags |= RTEMS_RTL_OBJ_SECT_LINK;
4000b9d4: 03 00 00 10 sethi %hi(0x4000), %g1
<== NOT EXECUTED
4000b9d8: ba 17 40 01 or %i5, %g1, %i5
<== NOT EXECUTED
if (!rtems_rtl_obj_cache_read (strings, fd,
4000b9dc: 86 84 40 0a addcc %l1, %o2, %g3
len = RTEMS_RTL_ELF_STRING_MAX;
4000b9e0: 82 10 21 00 mov 0x100, %g1
if (!rtems_rtl_obj_cache_read (strings, fd,
4000b9e4: 84 44 20 00 addx %l0, 0, %g2
4000b9e8: d0 07 bf 98 ld [ %fp + -104 ], %o0
4000b9ec: 94 10 00 02 mov %g2, %o2
4000b9f0: 96 10 00 03 mov %g3, %o3
4000b9f4: 9a 07 bf a0 add %fp, -96, %o5
len = RTEMS_RTL_ELF_STRING_MAX;
4000b9f8: c2 27 bf a0 st %g1, [ %fp + -96 ]
if (!rtems_rtl_obj_cache_read (strings, fd,
4000b9fc: 98 07 bf 9c add %fp, -100, %o4
4000ba00: 40 00 04 d9 call 4000cd64 <rtems_rtl_obj_cache_read>
4000ba04: 92 10 00 19 mov %i1, %o1
4000ba08: 80 a2 20 00 cmp %o0, 0
4000ba0c: 02 bf ff 5c be 4000b77c <rtems_rtl_elf_file_load+0xec>
<== NEVER TAKEN
4000ba10: e4 07 bf 9c ld [ %fp + -100 ], %l2
if (strcmp (".ctors", name) == 0)
4000ba14: 92 10 00 12 mov %l2, %o1
4000ba18: 40 00 42 64 call 4001c3a8 <strcmp>
4000ba1c: 90 10 00 14 mov %l4, %o0
4000ba20: 80 a2 20 00 cmp %o0, 0
4000ba24: 12 80 00 04 bne 4000ba34 <rtems_rtl_elf_file_load+0x3a4>
<== ALWAYS TAKEN
4000ba28: 92 10 00 12 mov %l2, %o1
flags |= RTEMS_RTL_OBJ_SECT_CTOR;
4000ba2c: 03 00 00 20 sethi %hi(0x8000), %g1
<== NOT EXECUTED
4000ba30: ba 17 40 01 or %i5, %g1, %i5
<== NOT EXECUTED
if (strcmp (".dtors", name) == 0)
4000ba34: 40 00 42 5d call 4001c3a8 <strcmp>
4000ba38: 90 10 00 1a mov %i2, %o0
4000ba3c: 80 a2 20 00 cmp %o0, 0
4000ba40: 12 80 00 05 bne 4000ba54 <rtems_rtl_elf_file_load+0x3c4>
<== ALWAYS TAKEN
4000ba44: 94 10 00 1d mov %i5, %o2
flags |= RTEMS_RTL_OBJ_SECT_DTOR;
4000ba48: 03 00 00 40 sethi %hi(0x10000), %g1
<== NOT EXECUTED
4000ba4c: ba 17 40 01 or %i5, %g1, %i5
<== NOT EXECUTED
if (rtems_rtl_elf_unwind_parse (obj, name, flags))
4000ba50: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
4000ba54: 92 10 00 12 mov %l2, %o1
4000ba58: 40 00 02 1c call 4000c2c8 <rtems_rtl_elf_unwind_parse>
4000ba5c: 90 10 00 18 mov %i0, %o0
4000ba60: 80 a2 20 00 cmp %o0, 0
4000ba64: 02 80 00 04 be 4000ba74 <rtems_rtl_elf_file_load+0x3e4>
4000ba68: c2 07 bf c0 ld [ %fp + -64 ], %g1
flags &= ~(RTEMS_RTL_OBJ_SECT_TEXT | RTEMS_RTL_OBJ_SECT_CONST);
4000ba6c: ba 0f 7f fc and %i5, -4, %i5
flags |= RTEMS_RTL_OBJ_SECT_EH;
4000ba70: ba 17 60 10 or %i5, 0x10, %i5
if (!rtems_rtl_obj_add_section (obj, section, name,
4000ba74: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
4000ba78: 98 10 20 00 clr %o4
4000ba7c: c2 07 bf bc ld [ %fp + -68 ], %g1
4000ba80: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
4000ba84: 92 10 00 1c mov %i4, %o1
4000ba88: c2 07 bf c4 ld [ %fp + -60 ], %g1
4000ba8c: fa 23 a0 68 st %i5, [ %sp + 0x68 ]
4000ba90: 90 10 00 18 mov %i0, %o0
4000ba94: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4000ba98: d6 07 bf b8 ld [ %fp + -72 ], %o3
4000ba9c: d4 07 bf 9c ld [ %fp + -100 ], %o2
4000baa0: 40 00 0a bf call 4000e59c <rtems_rtl_obj_add_section>
4000baa4: da 07 bf b4 ld [ %fp + -76 ], %o5
4000baa8: 80 a2 20 00 cmp %o0, 0
4000baac: 12 bf ff bf bne 4000b9a8 <rtems_rtl_elf_file_load+0x318>
<== ALWAYS TAKEN
4000bab0: c2 17 bf fc lduh [ %fp + -4 ], %g1
return false;
4000bab4: 10 bf ff 33 b 4000b780 <rtems_rtl_elf_file_load+0xf0>
<== NOT EXECUTED
4000bab8: b0 10 20 00 clr %i0
<== NOT EXECUTED
if ((shdr.sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE))
4000babc: c2 07 bf ac ld [ %fp + -84 ], %g1
4000bac0: 84 08 60 03 and %g1, 3, %g2
4000bac4: 80 a0 a0 03 cmp %g2, 3
4000bac8: 32 bf ff b8 bne,a 4000b9a8 <rtems_rtl_elf_file_load+0x318>
<== NEVER TAKEN
4000bacc: c2 17 bf fc lduh [ %fp + -4 ], %g1
<== NOT EXECUTED
flags = RTEMS_RTL_OBJ_SECT_BSS | RTEMS_RTL_OBJ_SECT_ZERO;
4000bad0: 3b 00 00 08 sethi %hi(0x2000), %i5
4000bad4: 10 bf ff bd b 4000b9c8 <rtems_rtl_elf_file_load+0x338>
4000bad8: ba 17 60 08 or %i5, 8, %i5 ! 2008 <_Configuration_Interrupt_stack_size+0x8>
flags = RTEMS_RTL_OBJ_SECT_RELA;
4000badc: ba 10 20 40 mov 0x40, %i5
4000bae0: 10 bf ff ba b 4000b9c8 <rtems_rtl_elf_file_load+0x338>
4000bae4: c2 07 bf ac ld [ %fp + -84 ], %g1
flags = RTEMS_RTL_OBJ_SECT_STR;
4000bae8: ba 10 21 00 mov 0x100, %i5
4000baec: 10 bf ff b7 b 4000b9c8 <rtems_rtl_elf_file_load+0x338>
4000baf0: c2 07 bf ac ld [ %fp + -84 ], %g1
flags = RTEMS_RTL_OBJ_SECT_SYM;
4000baf4: ba 10 20 80 mov 0x80, %i5
4000baf8: 10 bf ff b4 b 4000b9c8 <rtems_rtl_elf_file_load+0x338>
4000bafc: c2 07 bf ac ld [ %fp + -84 ], %g1
if ((shdr.sh_flags & SHF_ALLOC) == SHF_ALLOC)
4000bb00: c2 07 bf ac ld [ %fp + -84 ], %g1
4000bb04: 80 88 60 02 btst 2, %g1
4000bb08: 22 bf ff a8 be,a 4000b9a8 <rtems_rtl_elf_file_load+0x318>
4000bb0c: c2 17 bf fc lduh [ %fp + -4 ], %g1
if ((shdr.sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR)
4000bb10: 80 88 60 04 btst 4, %g1
4000bb14: 12 bf ff ad bne 4000b9c8 <rtems_rtl_elf_file_load+0x338>
4000bb18: ba 10 24 01 mov 0x401, %i5
else if ((shdr.sh_flags & SHF_WRITE) == SHF_WRITE)
4000bb1c: 80 88 60 01 btst 1, %g1
4000bb20: 02 bf ff aa be 4000b9c8 <rtems_rtl_elf_file_load+0x338>
4000bb24: ba 10 24 02 mov 0x402, %i5
flags = RTEMS_RTL_OBJ_SECT_DATA | RTEMS_RTL_OBJ_SECT_LOAD;
4000bb28: 10 bf ff a8 b 4000b9c8 <rtems_rtl_elf_file_load+0x338>
4000bb2c: ba 10 24 04 mov 0x404, %i5
rtems_rtl_set_error (EINVAL, "unsupported ELF file type");
4000bb30: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
4000bb34: 13 10 00 c2 sethi %hi(0x40030800), %o1
<== NOT EXECUTED
return false;
4000bb38: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "unsupported ELF file type");
4000bb3c: 40 00 00 ac call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000bb40: 92 12 61 48 or %o1, 0x148, %o1
<== NOT EXECUTED
4000bb44: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
4000bb48: 81 c7 e0 08 ret
<== NOT EXECUTED
4000bb4c: 81 e8 00 00 restore
<== NOT EXECUTED
obj->entry = (void*)(uintptr_t) ehdr.e_entry;
4000bb50: c2 07 bf e4 ld [ %fp + -28 ], %g1
<== NOT EXECUTED
4000bb54: c2 26 20 78 st %g1, [ %i0 + 0x78 ]
if (!rtems_rtl_obj_load_sections (obj, fd, rtems_rtl_elf_loader, &ehdr))
4000bb58: 96 07 bf cc add %fp, -52, %o3
4000bb5c: 92 10 00 19 mov %i1, %o1
4000bb60: 15 10 00 2b sethi %hi(0x4000ac00), %o2
4000bb64: 90 10 00 18 mov %i0, %o0
4000bb68: 40 00 0b 2c call 4000e818 <rtems_rtl_obj_load_sections>
4000bb6c: 94 12 a2 88 or %o2, 0x288, %o2
4000bb70: 80 a2 20 00 cmp %o0, 0
4000bb74: 22 bf ff 03 be,a 4000b780 <rtems_rtl_elf_file_load+0xf0>
<== NEVER TAKEN
4000bb78: b0 10 20 00 clr %i0
<== NOT EXECUTED
if (!rtems_rtl_obj_load_symbols (obj, fd, rtems_rtl_elf_symbols, &ehdr))
4000bb7c: 96 07 bf cc add %fp, -52, %o3
4000bb80: 92 10 00 19 mov %i1, %o1
4000bb84: 15 10 00 2a sethi %hi(0x4000a800), %o2
4000bb88: 90 10 00 18 mov %i0, %o0
4000bb8c: 40 00 0b 09 call 4000e7b0 <rtems_rtl_obj_load_symbols>
4000bb90: 94 12 a0 c0 or %o2, 0xc0, %o2
4000bb94: 80 a2 20 00 cmp %o0, 0
4000bb98: 22 bf fe fa be,a 4000b780 <rtems_rtl_elf_file_load+0xf0>
<== NEVER TAKEN
4000bb9c: b0 10 20 00 clr %i0
<== NOT EXECUTED
if (!rtems_rtl_obj_relocate (obj, fd, rtems_rtl_elf_relocator, &ehdr))
4000bba0: 96 07 bf cc add %fp, -52, %o3
4000bba4: 92 10 00 19 mov %i1, %o1
4000bba8: 15 10 00 2c sethi %hi(0x4000b000), %o2
4000bbac: 90 10 00 18 mov %i0, %o0
4000bbb0: 40 00 0a c8 call 4000e6d0 <rtems_rtl_obj_relocate>
4000bbb4: 94 12 a0 04 or %o2, 4, %o2
4000bbb8: 80 a2 20 00 cmp %o0, 0
4000bbbc: 22 bf fe f1 be,a 4000b780 <rtems_rtl_elf_file_load+0xf0>
<== NEVER TAKEN
4000bbc0: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_obj_synchronize_cache (obj);
4000bbc4: 40 00 0a dd call 4000e738 <rtems_rtl_obj_synchronize_cache>
4000bbc8: 90 10 00 18 mov %i0, %o0
rtems_rtl_symbol_obj_erase_local (obj);
4000bbcc: 40 00 12 5b call 40010538 <rtems_rtl_symbol_obj_erase_local>
4000bbd0: 90 10 00 18 mov %i0, %o0
return _Chain_Immutable_head( the_chain )->next;
4000bbd4: c8 06 20 2c ld [ %i0 + 0x2c ], %g4
4000bbd8: 86 10 20 04 mov 4, %g3
int sec_num = 0;
4000bbdc: ba 10 20 00 clr %i5
for (mask = RTEMS_RTL_OBJ_SECT_TEXT;
4000bbe0: 84 10 20 01 mov 1, %g2
4000bbe4: b4 06 20 30 add %i0, 0x30, %i2
node = rtems_chain_first (sections);
4000bbe8: 82 10 00 04 mov %g4, %g1
while (!rtems_chain_is_tail (sections, node))
4000bbec: 80 a0 40 1a cmp %g1, %i2
4000bbf0: 22 80 00 0c be,a 4000bc20 <rtems_rtl_elf_file_load+0x590>
4000bbf4: 86 80 ff ff addcc %g3, -1, %g3
if ((sect->size != 0) && ((sect->flags & mask) != 0))
4000bbf8: f8 00 60 10 ld [ %g1 + 0x10 ], %i4
4000bbfc: 80 a7 20 00 cmp %i4, 0
4000bc00: 22 bf ff fb be,a 4000bbec <rtems_rtl_elf_file_load+0x55c>
<== NEVER TAKEN
4000bc04: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
4000bc08: f8 00 60 2c ld [ %g1 + 0x2c ], %i4
4000bc0c: 80 88 80 1c btst %g2, %i4
4000bc10: 32 80 00 02 bne,a 4000bc18 <rtems_rtl_elf_file_load+0x588>
4000bc14: ba 07 60 01 inc %i5
4000bc18: 10 bf ff f5 b 4000bbec <rtems_rtl_elf_file_load+0x55c>
4000bc1c: c2 00 40 00 ld [ %g1 ], %g1
for (mask = RTEMS_RTL_OBJ_SECT_TEXT;
4000bc20: 12 bf ff f2 bne 4000bbe8 <rtems_rtl_elf_file_load+0x558>
4000bc24: 85 28 a0 01 sll %g2, 1, %g2
obj->obj_num = 1;
4000bc28: 82 10 20 01 mov 1, %g1
4000bc2c: c2 26 20 84 st %g1, [ %i0 + 0x84 ]
sec_num * sizeof (section_detail), true);
4000bc30: 93 2f 60 04 sll %i5, 4, %o1
obj->linkmap = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_OBJECT,
4000bc34: 94 10 20 01 mov 1, %o2
4000bc38: 92 02 60 34 add %o1, 0x34, %o1
4000bc3c: 7f ff f9 fa call 4000a424 <rtems_rtl_alloc_new>
4000bc40: 90 10 20 00 clr %o0
if (!obj->linkmap)
4000bc44: 80 a2 20 00 cmp %o0, 0
4000bc48: 02 80 00 4a be 4000bd70 <rtems_rtl_elf_file_load+0x6e0>
<== NEVER TAKEN
4000bc4c: d0 26 20 88 st %o0, [ %i0 + 0x88 ]
obj->linkmap->name = obj->oname;
4000bc50: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
obj->linkmap->sec_addr[rap_text] = obj->text_base;
4000bc54: d8 06 20 54 ld [ %i0 + 0x54 ], %o4
obj->linkmap->sec_addr[rap_const] = obj->const_base;
4000bc58: da 06 20 5c ld [ %i0 + 0x5c ], %o5
obj->linkmap->sec_addr[rap_data] = obj->data_base;
4000bc5c: de 06 20 68 ld [ %i0 + 0x68 ], %o7
obj->linkmap->sec_addr[rap_bss] = obj->bss_base;
4000bc60: f2 06 20 6c ld [ %i0 + 0x6c ], %i1
obj->linkmap->sec_detail = (section_detail*) (obj->linkmap + 1);
4000bc64: 88 02 20 34 add %o0, 0x34, %g4
obj->linkmap->name = obj->oname;
4000bc68: c2 22 00 00 st %g1, [ %o0 ]
4000bc6c: b8 10 20 04 mov 4, %i4
obj->linkmap->sec_detail = (section_detail*) (obj->linkmap + 1);
4000bc70: c8 22 20 08 st %g4, [ %o0 + 8 ]
for (mask = RTEMS_RTL_OBJ_SECT_TEXT;
4000bc74: 86 10 20 01 mov 1, %g3
obj->linkmap->rpathlen = 0;
4000bc78: c0 22 20 24 clr [ %o0 + 0x24 ]
sd[i].rap_id = rap_bss;
4000bc7c: 94 10 20 05 mov 5, %o2
obj->linkmap->rpath = NULL;
4000bc80: c0 22 20 28 clr [ %o0 + 0x28 ]
sd[i].rap_id = rap_const;
4000bc84: 96 10 20 01 mov 1, %o3
obj->linkmap->l_next = NULL;
4000bc88: c0 22 20 2c clr [ %o0 + 0x2c ]
obj->linkmap->l_prev = NULL;
4000bc8c: c0 22 20 30 clr [ %o0 + 0x30 ]
obj->linkmap->sec_addr[rap_text] = obj->text_base;
4000bc90: d8 22 20 0c st %o4, [ %o0 + 0xc ]
obj->linkmap->sec_addr[rap_const] = obj->const_base;
4000bc94: da 22 20 10 st %o5, [ %o0 + 0x10 ]
obj->linkmap->sec_addr[rap_data] = obj->data_base;
4000bc98: de 22 20 1c st %o7, [ %o0 + 0x1c ]
obj->linkmap->sec_addr[rap_bss] = obj->bss_base;
4000bc9c: f2 22 20 20 st %i1, [ %o0 + 0x20 ]
4000bca0: d2 06 20 2c ld [ %i0 + 0x2c ], %o1
obj->linkmap->sec_num = sec_num;
4000bca4: fa 22 20 04 st %i5, [ %o0 + 4 ]
int i = 0;
4000bca8: ba 10 20 00 clr %i5
node = rtems_chain_first (sections);
4000bcac: 84 10 00 09 mov %o1, %g2
while (!rtems_chain_is_tail (sections, node))
4000bcb0: 80 a6 80 02 cmp %i2, %g2
4000bcb4: 22 80 00 23 be,a 4000bd40 <rtems_rtl_elf_file_load+0x6b0>
4000bcb8: b8 87 3f ff addcc %i4, -1, %i4
if ((sect->size != 0) && ((sect->flags & mask) != 0))
4000bcbc: f6 00 a0 10 ld [ %g2 + 0x10 ], %i3
4000bcc0: 80 a6 e0 00 cmp %i3, 0
4000bcc4: 22 bf ff fb be,a 4000bcb0 <rtems_rtl_elf_file_load+0x620>
<== NEVER TAKEN
4000bcc8: c4 00 80 00 ld [ %g2 ], %g2
<== NOT EXECUTED
4000bccc: c2 00 a0 2c ld [ %g2 + 0x2c ], %g1
4000bcd0: 80 88 c0 01 btst %g3, %g1
4000bcd4: 22 bf ff f7 be,a 4000bcb0 <rtems_rtl_elf_file_load+0x620>
4000bcd8: c4 00 80 00 ld [ %g2 ], %g2
sd[i].name = sect->name;
4000bcdc: d0 00 a0 0c ld [ %g2 + 0xc ], %o0
4000bce0: 83 2f 60 04 sll %i5, 4, %g1
4000bce4: d0 21 00 01 st %o0, [ %g4 + %g1 ]
4000bce8: 82 01 00 01 add %g4, %g1, %g1
if (mask == RTEMS_RTL_OBJ_SECT_TEXT)
4000bcec: 80 a0 e0 01 cmp %g3, 1
4000bcf0: 02 80 00 1a be 4000bd58 <rtems_rtl_elf_file_load+0x6c8>
4000bcf4: f6 20 60 08 st %i3, [ %g1 + 8 ]
if (mask == RTEMS_RTL_OBJ_SECT_CONST)
4000bcf8: 80 a0 e0 02 cmp %g3, 2
4000bcfc: 12 80 00 25 bne 4000bd90 <rtems_rtl_elf_file_load+0x700>
<== NEVER TAKEN
4000bd00: 80 a0 e0 04 cmp %g3, 4
sd[i].offset = sect->base - obj->const_base;
4000bd04: f6 00 a0 30 ld [ %g2 + 0x30 ], %i3
4000bd08: b6 26 c0 0d sub %i3, %o5, %i3
sd[i].rap_id = rap_const;
4000bd0c: d6 20 60 0c st %o3, [ %g1 + 0xc ]
sd[i].offset = sect->base - obj->const_base;
4000bd10: f6 20 60 04 st %i3, [ %g1 + 4 ]
++i;
4000bd14: ba 07 60 01 inc %i5
4000bd18: 10 bf ff e6 b 4000bcb0 <rtems_rtl_elf_file_load+0x620>
4000bd1c: c4 00 80 00 ld [ %g2 ], %g2
rtems_rtl_set_error (EINVAL, "bad .sectstr section type");
4000bd20: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
4000bd24: 13 10 00 c2 sethi %hi(0x40030800), %o1
<== NOT EXECUTED
return false;
4000bd28: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "bad .sectstr section type");
4000bd2c: 40 00 00 30 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000bd30: 92 12 61 b0 or %o1, 0x1b0, %o1
<== NOT EXECUTED
4000bd34: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
4000bd38: 81 c7 e0 08 ret
<== NOT EXECUTED
4000bd3c: 81 e8 00 00 restore
<== NOT EXECUTED
for (mask = RTEMS_RTL_OBJ_SECT_TEXT;
4000bd40: 12 bf ff db bne 4000bcac <rtems_rtl_elf_file_load+0x61c>
4000bd44: 87 28 e0 01 sll %g3, 1, %g3
if (!rtems_rtl_elf_unwind_register (obj))
4000bd48: 40 00 01 63 call 4000c2d4 <rtems_rtl_elf_unwind_register>
4000bd4c: 90 10 00 18 mov %i0, %o0
4000bd50: 10 bf fe 6b b 4000b6fc <rtems_rtl_elf_file_load+0x6c>
4000bd54: b0 10 00 08 mov %o0, %i0
sd[i].offset = sect->base - obj->text_base;
4000bd58: f6 00 a0 30 ld [ %g2 + 0x30 ], %i3
4000bd5c: b6 26 c0 0c sub %i3, %o4, %i3
sd[i].rap_id = rap_text;
4000bd60: c0 20 60 0c clr [ %g1 + 0xc ]
++i;
4000bd64: ba 07 60 01 inc %i5
sd[i].offset = sect->base - obj->text_base;
4000bd68: 10 bf ff ec b 4000bd18 <rtems_rtl_elf_file_load+0x688>
4000bd6c: f6 20 60 04 st %i3, [ %g1 + 4 ]
rtems_rtl_set_error (ENOMEM, "no memory for obj linkmap");
4000bd70: 90 10 20 0c mov 0xc, %o0
<== NOT EXECUTED
4000bd74: 13 10 00 c2 sethi %hi(0x40030800), %o1
<== NOT EXECUTED
return false;
4000bd78: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (ENOMEM, "no memory for obj linkmap");
4000bd7c: 40 00 00 1c call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000bd80: 92 12 62 78 or %o1, 0x278, %o1
<== NOT EXECUTED
4000bd84: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
4000bd88: 81 c7 e0 08 ret
<== NOT EXECUTED
4000bd8c: 81 e8 00 00 restore
<== NOT EXECUTED
if (mask == RTEMS_RTL_OBJ_SECT_DATA)
4000bd90: 12 80 00 07 bne 4000bdac <rtems_rtl_elf_file_load+0x71c>
<== NOT EXECUTED
4000bd94: 80 a0 e0 08 cmp %g3, 8
<== NOT EXECUTED
sd[i].offset = sect->base - obj->data_base;
4000bd98: f6 00 a0 30 ld [ %g2 + 0x30 ], %i3
<== NOT EXECUTED
4000bd9c: b6 26 c0 0f sub %i3, %o7, %i3
<== NOT EXECUTED
sd[i].rap_id = rap_data;
4000bda0: c6 20 60 0c st %g3, [ %g1 + 0xc ]
<== NOT EXECUTED
sd[i].offset = sect->base - obj->data_base;
4000bda4: 10 bf ff dc b 4000bd14 <rtems_rtl_elf_file_load+0x684>
<== NOT EXECUTED
4000bda8: f6 20 60 04 st %i3, [ %g1 + 4 ]
<== NOT EXECUTED
if (mask == RTEMS_RTL_OBJ_SECT_BSS)
4000bdac: 32 bf ff db bne,a 4000bd18 <rtems_rtl_elf_file_load+0x688>
<== NOT EXECUTED
4000bdb0: ba 07 60 01 inc %i5
<== NOT EXECUTED
sd[i].offset = sect->base - obj->bss_base;
4000bdb4: f6 00 a0 30 ld [ %g2 + 0x30 ], %i3
<== NOT EXECUTED
4000bdb8: b6 26 c0 19 sub %i3, %i1, %i3
<== NOT EXECUTED
sd[i].rap_id = rap_bss;
4000bdbc: d4 20 60 0c st %o2, [ %g1 + 0xc ]
<== NOT EXECUTED
sd[i].offset = sect->base - obj->bss_base;
4000bdc0: 10 bf ff d5 b 4000bd14 <rtems_rtl_elf_file_load+0x684>
<== NOT EXECUTED
4000bdc4: f6 20 60 04 st %i3, [ %g1 + 4 ]
<== NOT EXECUTED
4000bde0 <rtems_rtl_elf_file_sig>:
rtems_rtl_loader_format*
rtems_rtl_elf_file_sig (void)
{
return &elf_sig;
4000bde0: 11 10 00 d3 sethi %hi(0x40034c00), %o0
<== NOT EXECUTED
}
4000bde4: 81 c3 e0 08 retl
<== NOT EXECUTED
4000bde8: 90 12 23 7c or %o0, 0x37c, %o0 ! 40034f7c <elf_sig>
<== NOT EXECUTED
4000af50 <rtems_rtl_elf_find_symbol>:
{
4000af50: 9d e3 bf a0 save %sp, -96, %sp
if (ELF_ST_TYPE(sym->st_info) == STT_NOTYPE)
4000af54: c2 0e 60 0c ldub [ %i1 + 0xc ], %g1
4000af58: 80 88 60 0f btst 0xf, %g1
4000af5c: 32 80 00 0e bne,a 4000af94 <rtems_rtl_elf_find_symbol+0x44>
4000af60: d2 16 60 0e lduh [ %i1 + 0xe ], %o1
rtems_rtl_obj_sym* symbol = rtems_rtl_symbol_obj_find (obj, symname);
4000af64: 92 10 00 1a mov %i2, %o1
4000af68: 40 00 15 3c call 40010458 <rtems_rtl_symbol_obj_find>
4000af6c: 90 10 00 18 mov %i0, %o0
if (!symbol)
4000af70: 80 a2 20 00 cmp %o0, 0
4000af74: 02 80 00 15 be 4000afc8 <rtems_rtl_elf_find_symbol+0x78>
4000af78: 94 10 00 1a mov %i2, %o2
*value = (Elf_Addr) symbol->value;
4000af7c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4000af80: c2 26 c0 00 st %g1, [ %i3 ]
return true;
4000af84: b0 10 20 01 mov 1, %i0
}
4000af88: b0 0e 20 01 and %i0, 1, %i0
4000af8c: 81 c7 e0 08 ret
4000af90: 81 e8 00 00 restore
sect = rtems_rtl_obj_find_section_by_index (obj, sym->st_shndx);
4000af94: 40 00 0d c4 call 4000e6a4 <rtems_rtl_obj_find_section_by_index>
4000af98: 90 10 00 18 mov %i0, %o0
if (!sect)
4000af9c: 80 a2 20 00 cmp %o0, 0
4000afa0: 22 80 00 12 be,a 4000afe8 <rtems_rtl_elf_find_symbol+0x98>
<== NEVER TAKEN
4000afa4: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
*value = sym->st_value + (Elf_Addr) sect->base;
4000afa8: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
4000afac: c4 06 60 04 ld [ %i1 + 4 ], %g2
4000afb0: 82 00 40 02 add %g1, %g2, %g1
4000afb4: c2 26 c0 00 st %g1, [ %i3 ]
return true;
4000afb8: b0 10 20 01 mov 1, %i0
}
4000afbc: b0 0e 20 01 and %i0, 1, %i0
4000afc0: 81 c7 e0 08 ret
4000afc4: 81 e8 00 00 restore
rtems_rtl_set_error (EINVAL, "global symbol not found: %s", symname);
4000afc8: 90 10 20 16 mov 0x16, %o0
4000afcc: 13 10 00 c1 sethi %hi(0x40030400), %o1
return false;
4000afd0: b0 10 20 00 clr %i0
rtems_rtl_set_error (EINVAL, "global symbol not found: %s", symname);
4000afd4: 40 00 03 86 call 4000bdec <rtems_rtl_set_error>
4000afd8: 92 12 63 80 or %o1, 0x380, %o1
4000afdc: b0 0e 20 01 and %i0, 1, %i0
4000afe0: 81 c7 e0 08 ret
4000afe4: 81 e8 00 00 restore
rtems_rtl_set_error (EINVAL, "reloc symbol's section not found");
4000afe8: 13 10 00 c1 sethi %hi(0x40030400), %o1
<== NOT EXECUTED
4000afec: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000aff0: 40 00 03 7f call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000aff4: 92 12 63 a0 or %o1, 0x3a0, %o1
<== NOT EXECUTED
4000aff8: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
4000affc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000b000: 81 e8 00 00 restore
<== NOT EXECUTED
4000c2ac <rtems_rtl_elf_relocate_rel>:
const Elf_Rel* rel,
const rtems_rtl_obj_sect* sect,
const char* symname,
const Elf_Byte syminfo,
const Elf_Word symvalue)
{
4000c2ac: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
printf ("rtl: rel type record not supported; please report\n");
return false;
}
4000c2b0: b0 10 20 00 clr %i0
<== NOT EXECUTED
printf ("rtl: rel type record not supported; please report\n");
4000c2b4: 11 10 00 c2 sethi %hi(0x40030800), %o0
<== NOT EXECUTED
4000c2b8: 40 00 31 b3 call 40018984 <__wrap_puts>
<== NOT EXECUTED
4000c2bc: 90 12 23 78 or %o0, 0x378, %o0 ! 40030b78 <tag_labels+0x53c>
<== NOT EXECUTED
}
4000c2c0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c2c4: 81 e8 00 00 restore
<== NOT EXECUTED
4000c094 <rtems_rtl_elf_relocate_rela>:
const Elf_Rela* rela,
const rtems_rtl_obj_sect* sect,
const char* symname,
const Elf_Byte syminfo,
const Elf_Word symvalue)
{
4000c094: 9d e3 bf a0 save %sp, -96, %sp
Elf_Word type, value, mask;
Elf_Addr tmp = 0;
where = (Elf_Addr *) (sect->base + rela->r_offset);
type = ELF_R_TYPE(rela->r_info);
4000c098: c4 0e 60 07 ldub [ %i1 + 7 ], %g2
/* We do JMP_SLOTs in _rtld_bind() below */
if (type == R_TYPE(JMP_SLOT))
return true;
/* COPY relocs are also handled elsewhere */
if (type == R_TYPE(COPY))
4000c09c: 82 00 bf ed add %g2, -19, %g1
4000c0a0: 82 08 7f fd and %g1, -3, %g1
4000c0a4: 80 a0 00 01 cmp %g0, %g1
4000c0a8: 82 60 3f ff subx %g0, -1, %g1
if (type == R_TYPE(NONE))
4000c0ac: 80 a0 00 02 cmp %g0, %g2
4000c0b0: 86 60 3f ff subx %g0, -1, %g3
4000c0b4: 82 10 40 03 or %g1, %g3, %g1
if (type == R_TYPE(COPY))
4000c0b8: 80 a0 60 00 cmp %g1, 0
4000c0bc: 02 80 00 06 be 4000c0d4 <rtems_rtl_elf_relocate_rela+0x40>
<== ALWAYS TAKEN
4000c0c0: b8 10 00 01 mov %g1, %i4
return true;
4000c0c4: b8 10 20 01 mov 1, %i4
4000c0c8: b0 0f 20 ff and %i4, 0xff, %i0
printf ("rtl: %s %p @ %p in %s\n",
reloc_names[ELF_R_TYPE(rela->r_info)],
(void *)tmp, where, rtems_rtl_obj_oname (obj));
return true;
}
4000c0cc: 81 c7 e0 08 ret
4000c0d0: 81 e8 00 00 restore
if (type > R_TYPE(6))
4000c0d4: 80 a0 a0 2d cmp %g2, 0x2d
4000c0d8: 18 bf ff fc bgu 4000c0c8 <rtems_rtl_elf_relocate_rela+0x34>
<== NEVER TAKEN
4000c0dc: 80 a0 a0 16 cmp %g2, 0x16
where = (Elf_Addr *) (sect->base + rela->r_offset);
4000c0e0: c2 06 a0 30 ld [ %i2 + 0x30 ], %g1
4000c0e4: c6 06 40 00 ld [ %i1 ], %g3
4000c0e8: a2 00 40 03 add %g1, %g3, %l1
if (type == R_TYPE (RELATIVE)) {
4000c0ec: 02 80 00 5f be 4000c268 <rtems_rtl_elf_relocate_rela+0x1d4>
<== NEVER TAKEN
4000c0f0: e0 06 60 08 ld [ %i1 + 8 ], %l0
if (RELOC_RESOLVE_SYMBOL (type)) {
4000c0f4: b9 28 a0 02 sll %g2, 2, %i4
4000c0f8: 05 10 00 c3 sethi %hi(0x40030c00), %g2
4000c0fc: 84 10 a1 68 or %g2, 0x168, %g2 ! 40030d68 <reloc_target_flags>
4000c100: f6 00 80 1c ld [ %g2 + %i4 ], %i3
4000c104: 80 a6 e0 00 cmp %i3, 0
4000c108: 26 80 00 02 bl,a 4000c110 <rtems_rtl_elf_relocate_rela+0x7c>
<== ALWAYS TAKEN
4000c10c: a0 04 00 1d add %l0, %i5, %l0
if (RELOC_PC_RELATIVE (type)) {
4000c110: 05 08 00 00 sethi %hi(0x20000000), %g2
4000c114: 80 8e c0 02 btst %i3, %g2
4000c118: 32 80 00 02 bne,a 4000c120 <rtems_rtl_elf_relocate_rela+0x8c>
4000c11c: a0 24 00 11 sub %l0, %l1, %l0
if (RELOC_BASE_RELATIVE (type)) {
4000c120: 05 02 00 00 sethi %hi(0x8000000), %g2
4000c124: 80 8e c0 02 btst %i3, %g2
4000c128: 22 80 00 08 be,a 4000c148 <rtems_rtl_elf_relocate_rela+0xb4>
<== ALWAYS TAKEN
4000c12c: 03 10 00 c2 sethi %hi(0x40030800), %g1
if (value != 0 && *where != 0) {
4000c130: 80 a4 20 00 cmp %l0, 0
<== NOT EXECUTED
4000c134: 12 80 00 38 bne 4000c214 <rtems_rtl_elf_relocate_rela+0x180>
<== NOT EXECUTED
4000c138: c4 04 40 00 ld [ %l1 ], %g2
<== NOT EXECUTED
value += (Elf_Word)(sect->base + *where);
4000c13c: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
4000c140: a0 04 00 01 add %l0, %g1, %l0
<== NOT EXECUTED
mask = RELOC_VALUE_BITMASK (type);
4000c144: 03 10 00 c2 sethi %hi(0x40030800), %g1
<== NOT EXECUTED
4000c148: 82 10 63 ac or %g1, 0x3ac, %g1 ! 40030bac <reloc_target_bitmask>
4000c14c: f8 00 40 1c ld [ %g1 + %i4 ], %i4
value >>= RELOC_VALUE_RIGHTSHIFT (type);
4000c150: bb 34 00 1b srl %l0, %i3, %i5
if (RELOC_UNALIGNED(type)) {
4000c154: 03 01 00 00 sethi %hi(0x4000000), %g1
4000c158: 80 8e c0 01 btst %i3, %g1
4000c15c: 02 80 00 29 be 4000c200 <rtems_rtl_elf_relocate_rela+0x16c>
4000c160: ba 0f 00 1d and %i4, %i5, %i5
int i, size = RELOC_TARGET_SIZE (type) / 8;
4000c164: 83 36 e0 0b srl %i3, 0xb, %g1
4000c168: 82 08 60 1f and %g1, 0x1f, %g1
for (i = size - 1; i >= 0; i--)
4000c16c: 82 00 7f ff add %g1, -1, %g1
4000c170: 80 a0 7f ff cmp %g1, -1
4000c174: 02 80 00 10 be 4000c1b4 <rtems_rtl_elf_relocate_rela+0x120>
<== NEVER TAKEN
4000c178: 86 10 00 01 mov %g1, %g3
Elf_Addr tmp = 0;
4000c17c: 84 10 20 00 clr %g2
tmp = (tmp << 8) | ptr[i];
4000c180: c8 4c 40 03 ldsb [ %l1 + %g3 ], %g4
4000c184: 85 28 a0 08 sll %g2, 8, %g2
for (i = size - 1; i >= 0; i--)
4000c188: 86 00 ff ff add %g3, -1, %g3
4000c18c: 80 a0 ff ff cmp %g3, -1
4000c190: 12 bf ff fc bne 4000c180 <rtems_rtl_elf_relocate_rela+0xec>
4000c194: 84 11 00 02 or %g4, %g2, %g2
tmp &= ~mask;
4000c198: 84 28 80 1c andn %g2, %i4, %g2
tmp |= value;
4000c19c: ba 17 40 02 or %i5, %g2, %i5
ptr[i] = tmp & 0xff;
4000c1a0: fa 2c 40 01 stb %i5, [ %l1 + %g1 ]
for (i = size - 1; i >= 0; i--, tmp >>= 8)
4000c1a4: 82 00 7f ff add %g1, -1, %g1
4000c1a8: 80 a0 7f ff cmp %g1, -1
4000c1ac: 12 bf ff fd bne 4000c1a0 <rtems_rtl_elf_relocate_rela+0x10c>
4000c1b0: bb 37 60 08 srl %i5, 8, %i5
if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
4000c1b4: 40 00 11 14 call 40010604 <rtems_rtl_trace>
4000c1b8: 90 10 20 40 mov 0x40, %o0
4000c1bc: 80 a2 20 00 cmp %o0, 0
4000c1c0: 02 bf ff c1 be 4000c0c4 <rtems_rtl_elf_relocate_rela+0x30>
4000c1c4: b8 10 00 08 mov %o0, %i4
reloc_names[ELF_R_TYPE(rela->r_info)],
4000c1c8: c2 0e 60 07 ldub [ %i1 + 7 ], %g1
printf ("rtl: %s %p @ %p in %s\n",
4000c1cc: 83 28 60 02 sll %g1, 2, %g1
4000c1d0: d8 06 20 18 ld [ %i0 + 0x18 ], %o4
4000c1d4: 05 10 00 c3 sethi %hi(0x40030c00), %g2
4000c1d8: 84 10 a1 08 or %g2, 0x108, %g2 ! 40030d08 <reloc_names>
4000c1dc: d2 00 80 01 ld [ %g2 + %g1 ], %o1
4000c1e0: 96 10 00 11 mov %l1, %o3
4000c1e4: 94 10 00 1d mov %i5, %o2
4000c1e8: 11 10 00 c2 sethi %hi(0x40030800), %o0
4000c1ec: 40 00 31 d7 call 40018948 <__wrap_printf>
4000c1f0: 90 12 23 60 or %o0, 0x360, %o0 ! 40030b60 <tag_labels+0x524>
4000c1f4: b0 0f 20 ff and %i4, 0xff, %i0
4000c1f8: 81 c7 e0 08 ret
4000c1fc: 81 e8 00 00 restore
*where &= ~mask;
4000c200: c2 04 40 00 ld [ %l1 ], %g1
4000c204: b8 28 40 1c andn %g1, %i4, %i4
*where |= value;
4000c208: ba 17 40 1c or %i5, %i4, %i5
4000c20c: 10 bf ff ea b 4000c1b4 <rtems_rtl_elf_relocate_rela+0x120>
4000c210: fa 24 40 00 st %i5, [ %l1 ]
if (value != 0 && *where != 0) {
4000c214: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000c218: 02 bf ff ca be 4000c140 <rtems_rtl_elf_relocate_rela+0xac>
<== NOT EXECUTED
4000c21c: 82 00 40 02 add %g1, %g2, %g1
<== NOT EXECUTED
if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
4000c220: 40 00 10 f9 call 40010604 <rtems_rtl_trace>
<== NOT EXECUTED
4000c224: 90 10 20 40 mov 0x40, %o0
<== NOT EXECUTED
4000c228: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000c22c: 32 80 00 05 bne,a 4000c240 <rtems_rtl_elf_relocate_rela+0x1ac>
<== NOT EXECUTED
4000c230: da 06 a0 30 ld [ %i2 + 0x30 ], %o5
<== NOT EXECUTED
4000c234: c2 06 a0 30 ld [ %i2 + 0x30 ], %g1
<== NOT EXECUTED
4000c238: 10 bf ff c1 b 4000c13c <rtems_rtl_elf_relocate_rela+0xa8>
<== NOT EXECUTED
4000c23c: c4 04 40 00 ld [ %l1 ], %g2
<== NOT EXECUTED
printf("rtl: reloc base_rel(%s): where=%p, *where 0x%lx, "
4000c240: d8 06 60 08 ld [ %i1 + 8 ], %o4
<== NOT EXECUTED
4000c244: d6 04 40 00 ld [ %l1 ], %o3
<== NOT EXECUTED
4000c248: d2 06 20 18 ld [ %i0 + 0x18 ], %o1
<== NOT EXECUTED
4000c24c: 94 10 00 11 mov %l1, %o2
<== NOT EXECUTED
4000c250: 11 10 00 c2 sethi %hi(0x40030800), %o0
<== NOT EXECUTED
4000c254: 40 00 31 bd call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000c258: 90 12 23 18 or %o0, 0x318, %o0 ! 40030b18 <tag_labels+0x4dc>
<== NOT EXECUTED
4000c25c: c2 06 a0 30 ld [ %i2 + 0x30 ], %g1
<== NOT EXECUTED
4000c260: 10 bf ff b7 b 4000c13c <rtems_rtl_elf_relocate_rela+0xa8>
<== NOT EXECUTED
4000c264: c4 04 40 00 ld [ %l1 ], %g2
<== NOT EXECUTED
*where += (Elf_Addr)(sect->base + value);
4000c268: c4 00 40 03 ld [ %g1 + %g3 ], %g2
<== NOT EXECUTED
4000c26c: a0 00 40 10 add %g1, %l0, %l0
<== NOT EXECUTED
4000c270: a0 00 80 10 add %g2, %l0, %l0
<== NOT EXECUTED
4000c274: e0 20 40 03 st %l0, [ %g1 + %g3 ]
<== NOT EXECUTED
if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
4000c278: 40 00 10 e3 call 40010604 <rtems_rtl_trace>
<== NOT EXECUTED
4000c27c: 90 10 20 40 mov 0x40, %o0
<== NOT EXECUTED
4000c280: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000c284: 02 bf ff 90 be 4000c0c4 <rtems_rtl_elf_relocate_rela+0x30>
<== NOT EXECUTED
4000c288: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
printf ("rtl: reloc relative in %s --> %p",
4000c28c: d4 04 40 00 ld [ %l1 ], %o2
<== NOT EXECUTED
4000c290: d2 06 20 18 ld [ %i0 + 0x18 ], %o1
<== NOT EXECUTED
4000c294: 11 10 00 c2 sethi %hi(0x40030800), %o0
<== NOT EXECUTED
4000c298: 40 00 31 ac call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000c29c: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 40030af0 <tag_labels+0x4b4>
<== NOT EXECUTED
4000c2a0: b0 0f 20 ff and %i4, 0xff, %i0
<== NOT EXECUTED
4000c2a4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c2a8: 81 e8 00 00 restore
<== NOT EXECUTED
40010edc <rtems_rtl_elf_unwind_dw2_deregister>:
bool rtems_rtl_elf_unwind_dw2_deregister (const rtems_rtl_obj* obj)
{
40010edc: 9d e3 bf a0 save %sp, -96, %sp
rtems_rtl_obj_sect* sect = rtems_rtl_obj_find_section (obj, ".eh_frame");
40010ee0: 13 10 00 c6 sethi %hi(0x40031800), %o1
40010ee4: 90 10 00 18 mov %i0, %o0
40010ee8: 7f ff f5 e4 call 4000e678 <rtems_rtl_obj_find_section>
40010eec: 92 12 63 60 or %o1, 0x360, %o1
if (sect != NULL && sect->size > 0 && sect->base != NULL)
40010ef0: 80 a2 20 00 cmp %o0, 0
40010ef4: 02 80 00 0c be 40010f24 <rtems_rtl_elf_unwind_dw2_deregister+0x48>
40010ef8: 01 00 00 00 nop
40010efc: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
40010f00: 80 a0 60 00 cmp %g1, 0
40010f04: 02 80 00 08 be 40010f24 <rtems_rtl_elf_unwind_dw2_deregister+0x48>
<== NEVER TAKEN
40010f08: 01 00 00 00 nop
40010f0c: d0 02 20 30 ld [ %o0 + 0x30 ], %o0
40010f10: 80 a2 20 00 cmp %o0, 0
40010f14: 02 80 00 04 be 40010f24 <rtems_rtl_elf_unwind_dw2_deregister+0x48>
<== NEVER TAKEN
40010f18: 01 00 00 00 nop
{
__deregister_frame (sect->base);
40010f1c: 7f ff c9 17 call 40003378 <__deregister_frame>
40010f20: 01 00 00 00 nop
}
return true;
}
40010f24: 81 c7 e0 08 ret
40010f28: 91 e8 20 01 restore %g0, 1, %o0
40010e8c <rtems_rtl_elf_unwind_dw2_register>:
bool
rtems_rtl_elf_unwind_dw2_register (const rtems_rtl_obj* obj)
{
40010e8c: 9d e3 bf a0 save %sp, -96, %sp
rtems_rtl_obj_sect* sect = rtems_rtl_obj_find_section (obj, ".eh_frame");
40010e90: 13 10 00 c6 sethi %hi(0x40031800), %o1
40010e94: 90 10 00 18 mov %i0, %o0
40010e98: 7f ff f5 f8 call 4000e678 <rtems_rtl_obj_find_section>
40010e9c: 92 12 63 60 or %o1, 0x360, %o1
if (sect != NULL && sect->size > 0 && sect->base != NULL)
40010ea0: 80 a2 20 00 cmp %o0, 0
40010ea4: 02 80 00 0c be 40010ed4 <rtems_rtl_elf_unwind_dw2_register+0x48>
40010ea8: 01 00 00 00 nop
40010eac: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
40010eb0: 80 a0 60 00 cmp %g1, 0
40010eb4: 02 80 00 08 be 40010ed4 <rtems_rtl_elf_unwind_dw2_register+0x48>
<== NEVER TAKEN
40010eb8: 01 00 00 00 nop
40010ebc: d0 02 20 30 ld [ %o0 + 0x30 ], %o0
40010ec0: 80 a2 20 00 cmp %o0, 0
40010ec4: 02 80 00 04 be 40010ed4 <rtems_rtl_elf_unwind_dw2_register+0x48>
<== NEVER TAKEN
40010ec8: 01 00 00 00 nop
{
__register_frame (sect->base);
40010ecc: 7f ff c8 ba call 400031b4 <__register_frame>
40010ed0: 01 00 00 00 nop
}
return true;
}
40010ed4: 81 c7 e0 08 ret
40010ed8: 91 e8 20 01 restore %g0, 1, %o0
4000be8c <rtems_rtl_find_file>:
bool
rtems_rtl_find_file (const char* name,
const char* paths,
const char** file_name,
size_t* size)
{
4000be8c: 9d e3 bf 40 save %sp, -192, %sp
struct stat sb;
*file_name = NULL;
4000be90: c0 26 80 00 clr [ %i2 ]
*size = 0;
4000be94: c0 26 c0 00 clr [ %i3 ]
if (rtems_filesystem_is_delimiter (name[0]) || (name[0] == '.'))
4000be98: c2 0e 00 00 ldub [ %i0 ], %g1
4000be9c: 86 00 7f d2 add %g1, -46, %g3
4000bea0: 80 a0 e0 01 cmp %g3, 1
4000bea4: 08 80 00 03 bleu 4000beb0 <rtems_rtl_find_file+0x24>
<== ALWAYS TAKEN
4000bea8: 84 10 20 01 mov 1, %g2
4000beac: 84 10 20 00 clr %g2
<== NOT EXECUTED
return c == '/' || c == '\\';
4000beb0: 83 28 60 18 sll %g1, 0x18, %g1
4000beb4: 83 38 60 18 sra %g1, 0x18, %g1
4000beb8: 82 18 60 5c xor %g1, 0x5c, %g1
4000bebc: 80 a0 00 01 cmp %g0, %g1
4000bec0: 82 60 3f ff subx %g0, -1, %g1
4000bec4: 82 10 40 02 or %g1, %g2, %g1
4000bec8: 80 88 60 01 btst 1, %g1
4000becc: 02 80 00 11 be 4000bf10 <rtems_rtl_find_file+0x84>
<== NEVER TAKEN
4000bed0: a8 10 00 01 mov %g1, %l4
{
if (stat (name, &sb) == 0)
4000bed4: 92 07 bf a0 add %fp, -96, %o1
4000bed8: 7f ff f2 d0 call 40008a18 <stat>
4000bedc: 90 10 00 18 mov %i0, %o0
4000bee0: 80 a2 20 00 cmp %o0, 0
4000bee4: 02 80 00 58 be 4000c044 <rtems_rtl_find_file+0x1b8>
<== ALWAYS TAKEN
4000bee8: 01 00 00 00 nop
4000beec: fa 06 80 00 ld [ %i2 ], %i5
<== NOT EXECUTED
if (start != end)
++start;
}
}
if (!*file_name)
4000bef0: 80 a7 60 00 cmp %i5, 0
4000bef4: 02 80 00 50 be 4000c034 <rtems_rtl_find_file+0x1a8>
<== NEVER TAKEN
4000bef8: c2 07 bf c4 ld [ %fp + -60 ], %g1
return false;
*size = sb.st_size;
4000befc: c2 26 c0 00 st %g1, [ %i3 ]
return true;
4000bf00: a8 10 20 01 mov 1, %l4
}
4000bf04: b0 0d 20 ff and %l4, 0xff, %i0
4000bf08: 81 c7 e0 08 ret
4000bf0c: 81 e8 00 00 restore
else if (paths)
4000bf10: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000bf14: 22 80 00 49 be,a 4000c038 <rtems_rtl_find_file+0x1ac>
<== NOT EXECUTED
4000bf18: a8 10 20 00 clr %l4
<== NOT EXECUTED
end = start + strlen (paths);
4000bf1c: 40 00 43 50 call 4001cc5c <strlen>
<== NOT EXECUTED
4000bf20: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
printf ("rtl: find-file: path: %s\n", fname);
4000bf24: 2d 10 00 c2 sethi %hi(0x40030800), %l6
<== NOT EXECUTED
end = start + strlen (paths);
4000bf28: a2 06 40 08 add %i1, %o0, %l1
<== NOT EXECUTED
while (!*file_name && (start != end))
4000bf2c: ba 10 20 00 clr %i5
<== NOT EXECUTED
len = strlen (name);
4000bf30: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000bf34: 40 00 43 4a call 4001cc5c <strlen>
<== NOT EXECUTED
4000bf38: aa 10 20 2f mov 0x2f, %l5
<== NOT EXECUTED
printf ("rtl: find-file: path: %s\n", fname);
4000bf3c: ac 15 a2 d0 or %l6, 0x2d0, %l6
<== NOT EXECUTED
len = strlen (name);
4000bf40: a6 10 00 08 mov %o0, %l3
<== NOT EXECUTED
while (!*file_name && (start != end))
4000bf44: 80 a6 40 11 cmp %i1, %l1
<== NOT EXECUTED
4000bf48: 02 bf ff eb be 4000bef4 <rtems_rtl_find_file+0x68>
<== NOT EXECUTED
4000bf4c: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
4000bf50: 12 bf ff e8 bne 4000bef0 <rtems_rtl_find_file+0x64>
<== NOT EXECUTED
4000bf54: 92 10 20 3a mov 0x3a, %o1
<== NOT EXECUTED
const char* delimiter = strchr (start, ':');
4000bf58: 40 00 40 a2 call 4001c1e0 <strchr>
<== NOT EXECUTED
4000bf5c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
if (delimiter == NULL)
4000bf60: b8 92 20 00 orcc %o0, 0, %i4
<== NOT EXECUTED
4000bf64: 22 80 00 02 be,a 4000bf6c <rtems_rtl_find_file+0xe0>
<== NOT EXECUTED
4000bf68: b8 10 00 11 mov %l1, %i4
<== NOT EXECUTED
(delimiter - start) + 1 + len + 1, true);
4000bf6c: a0 27 00 19 sub %i4, %i1, %l0
<== NOT EXECUTED
fname = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_OBJECT,
4000bf70: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
(delimiter - start) + 1 + len + 1, true);
4000bf74: a4 04 20 01 add %l0, 1, %l2
<== NOT EXECUTED
fname = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_OBJECT,
4000bf78: 90 10 20 00 clr %o0
<== NOT EXECUTED
(delimiter - start) + 1 + len + 1, true);
4000bf7c: 92 04 80 13 add %l2, %l3, %o1
<== NOT EXECUTED
fname = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_OBJECT,
4000bf80: 7f ff f9 29 call 4000a424 <rtems_rtl_alloc_new>
<== NOT EXECUTED
4000bf84: 92 02 60 01 inc %o1
<== NOT EXECUTED
if (!fname)
4000bf88: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
4000bf8c: 02 80 00 33 be 4000c058 <rtems_rtl_find_file+0x1cc>
<== NOT EXECUTED
4000bf90: 94 10 00 10 mov %l0, %o2
<== NOT EXECUTED
memcpy (fname, start, delimiter - start);
4000bf94: 40 00 3b 74 call 4001ad64 <memcpy>
<== NOT EXECUTED
4000bf98: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
fname[delimiter - start] = '/';
4000bf9c: ea 2f 40 10 stb %l5, [ %i5 + %l0 ]
<== NOT EXECUTED
memcpy (fname + (delimiter - start) + 1, name, len);
4000bfa0: 94 10 00 13 mov %l3, %o2
<== NOT EXECUTED
4000bfa4: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
4000bfa8: 40 00 3b 6f call 4001ad64 <memcpy>
<== NOT EXECUTED
4000bfac: 90 07 40 12 add %i5, %l2, %o0
<== NOT EXECUTED
if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD))
4000bfb0: 40 00 11 95 call 40010604 <rtems_rtl_trace>
<== NOT EXECUTED
4000bfb4: 90 10 20 04 mov 4, %o0
<== NOT EXECUTED
4000bfb8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000bfbc: 12 80 00 10 bne 4000bffc <rtems_rtl_find_file+0x170>
<== NOT EXECUTED
4000bfc0: 92 07 bf a0 add %fp, -96, %o1
<== NOT EXECUTED
if (stat (fname, &sb) < 0)
4000bfc4: 7f ff f2 95 call 40008a18 <stat>
<== NOT EXECUTED
4000bfc8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000bfcc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000bfd0: 06 80 00 15 bl 4000c024 <rtems_rtl_find_file+0x198>
<== NOT EXECUTED
4000bfd4: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
*file_name = fname;
4000bfd8: fa 26 80 00 st %i5, [ %i2 ]
<== NOT EXECUTED
if (start != end)
4000bfdc: 80 a7 00 11 cmp %i4, %l1
<== NOT EXECUTED
4000bfe0: 02 bf ff d9 be 4000bf44 <rtems_rtl_find_file+0xb8>
<== NOT EXECUTED
4000bfe4: b2 10 00 11 mov %l1, %i1
<== NOT EXECUTED
++start;
4000bfe8: b2 07 20 01 add %i4, 1, %i1
<== NOT EXECUTED
while (!*file_name && (start != end))
4000bfec: 80 a6 40 11 cmp %i1, %l1
<== NOT EXECUTED
4000bff0: 12 bf ff d8 bne 4000bf50 <rtems_rtl_find_file+0xc4>
<== NOT EXECUTED
4000bff4: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
4000bff8: 30 bf ff bf b,a 4000bef4 <rtems_rtl_find_file+0x68>
<== NOT EXECUTED
printf ("rtl: find-file: path: %s\n", fname);
4000bffc: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4000c000: 40 00 32 52 call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000c004: 90 10 00 16 mov %l6, %o0
<== NOT EXECUTED
if (stat (fname, &sb) < 0)
4000c008: 92 07 bf a0 add %fp, -96, %o1
<== NOT EXECUTED
4000c00c: 7f ff f2 83 call 40008a18 <stat>
<== NOT EXECUTED
4000c010: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000c014: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000c018: 36 bf ff f1 bge,a 4000bfdc <rtems_rtl_find_file+0x150>
<== NOT EXECUTED
4000c01c: fa 26 80 00 st %i5, [ %i2 ]
<== NOT EXECUTED
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_OBJECT, fname);
4000c020: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4000c024: 7f ff f9 29 call 4000a4c8 <rtems_rtl_alloc_del>
<== NOT EXECUTED
4000c028: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000c02c: 10 bf ff ec b 4000bfdc <rtems_rtl_find_file+0x150>
<== NOT EXECUTED
4000c030: fa 06 80 00 ld [ %i2 ], %i5
<== NOT EXECUTED
return false;
4000c034: a8 10 20 00 clr %l4
<== NOT EXECUTED
}
4000c038: b0 0d 20 ff and %l4, 0xff, %i0
<== NOT EXECUTED
4000c03c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c040: 81 e8 00 00 restore
<== NOT EXECUTED
*file_name = rtems_rtl_strdup (name);
4000c044: 40 00 0f d1 call 4000ff88 <rtems_rtl_strdup>
4000c048: 90 10 00 18 mov %i0, %o0
4000c04c: ba 10 00 08 mov %o0, %i5
4000c050: 10 bf ff a8 b 4000bef0 <rtems_rtl_find_file+0x64>
4000c054: d0 26 80 00 st %o0, [ %i2 ]
rtems_rtl_set_error (ENOMEM, "no memory searching for file");
4000c058: 90 10 20 0c mov 0xc, %o0
<== NOT EXECUTED
4000c05c: 13 10 00 c2 sethi %hi(0x40030800), %o1
<== NOT EXECUTED
4000c060: 7f ff ff 63 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000c064: 92 12 62 b0 or %o1, 0x2b0, %o1 ! 40030ab0 <tag_labels+0x474>
<== NOT EXECUTED
4000c068: b0 0d 20 ff and %l4, 0xff, %i0
<== NOT EXECUTED
4000c06c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c070: 81 e8 00 00 restore
<== NOT EXECUTED
4000c8a8 <rtems_rtl_find_obj>:
{
4000c8a8: 9d e3 bf 90 save %sp, -112, %sp
const char* aname = NULL;
4000c8ac: c0 27 bf f0 clr [ %fp + -16 ]
if (!rtems_rtl_parse_name (name, &aname, &oname, &ooffset))
4000c8b0: 96 07 bf f8 add %fp, -8, %o3
const char* oname = NULL;
4000c8b4: c0 27 bf f4 clr [ %fp + -12 ]
if (!rtems_rtl_parse_name (name, &aname, &oname, &ooffset))
4000c8b8: 94 07 bf f4 add %fp, -12, %o2
4000c8bc: 92 07 bf f0 add %fp, -16, %o1
4000c8c0: 40 00 04 e7 call 4000dc5c <rtems_rtl_parse_name>
4000c8c4: 90 10 00 18 mov %i0, %o0
4000c8c8: 80 a2 20 00 cmp %o0, 0
4000c8cc: 02 80 00 36 be 4000c9a4 <rtems_rtl_find_obj+0xfc>
<== NEVER TAKEN
4000c8d0: 03 10 00 d8 sethi %hi(0x40036000), %g1
node = rtems_chain_first (&rtl->objects);
4000c8d4: f8 00 61 e4 ld [ %g1 + 0x1e4 ], %i4 ! 400361e4 <rtl>
return _Chain_Immutable_head( the_chain )->next;
4000c8d8: f0 07 20 64 ld [ %i4 + 0x64 ], %i0
return &the_chain->Tail.Node;
4000c8dc: b8 07 20 68 add %i4, 0x68, %i4
while (!rtems_chain_is_tail (&rtl->objects, node))
4000c8e0: 80 a6 00 1c cmp %i0, %i4
4000c8e4: 02 80 00 25 be 4000c978 <rtems_rtl_find_obj+0xd0>
<== NEVER TAKEN
4000c8e8: fa 07 bf f0 ld [ %fp + -16 ], %i5
strcmp (obj->aname, aname) == 0 && strcmp (obj->oname, oname) == 0))
4000c8ec: 10 80 00 11 b 4000c930 <rtems_rtl_find_obj+0x88>
4000c8f0: f6 07 bf f4 ld [ %fp + -12 ], %i3
4000c8f4: 40 00 3e ad call 4001c3a8 <strcmp>
<== NOT EXECUTED
4000c8f8: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
(aname != NULL &&
4000c8fc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000c900: 32 80 00 09 bne,a 4000c924 <rtems_rtl_find_obj+0x7c>
<== NOT EXECUTED
4000c904: f0 06 00 00 ld [ %i0 ], %i0
<== NOT EXECUTED
strcmp (obj->aname, aname) == 0 && strcmp (obj->oname, oname) == 0))
4000c908: d0 06 20 18 ld [ %i0 + 0x18 ], %o0
<== NOT EXECUTED
4000c90c: 40 00 3e a7 call 4001c3a8 <strcmp>
<== NOT EXECUTED
4000c910: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4000c914: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000c918: 02 80 00 21 be 4000c99c <rtems_rtl_find_obj+0xf4>
<== NOT EXECUTED
4000c91c: 01 00 00 00 nop
<== NOT EXECUTED
4000c920: f0 06 00 00 ld [ %i0 ], %i0
<== NOT EXECUTED
while (!rtems_chain_is_tail (&rtl->objects, node))
4000c924: 80 a6 00 1c cmp %i0, %i4
4000c928: 02 80 00 15 be 4000c97c <rtems_rtl_find_obj+0xd4>
4000c92c: 80 a7 60 00 cmp %i5, 0
if ((aname == NULL && strcmp (obj->oname, oname) == 0) ||
4000c930: 80 a7 60 00 cmp %i5, 0
4000c934: 32 bf ff f0 bne,a 4000c8f4 <rtems_rtl_find_obj+0x4c>
<== NEVER TAKEN
4000c938: d0 06 20 1c ld [ %i0 + 0x1c ], %o0
<== NOT EXECUTED
4000c93c: d0 06 20 18 ld [ %i0 + 0x18 ], %o0
4000c940: 40 00 3e 9a call 4001c3a8 <strcmp>
4000c944: 92 10 00 1b mov %i3, %o1
4000c948: 80 a2 20 00 cmp %o0, 0
4000c94c: 32 bf ff f6 bne,a 4000c924 <rtems_rtl_find_obj+0x7c>
<== ALWAYS TAKEN
4000c950: f0 06 00 00 ld [ %i0 ], %i0
rtems_rtl_alloc_del(RTEMS_RTL_ALLOC_OBJECT, (void*) aname);
4000c954: 92 10 20 00 clr %o1
4000c958: 7f ff f6 dc call 4000a4c8 <rtems_rtl_alloc_del>
4000c95c: 90 10 20 00 clr %o0
4000c960: c2 07 bf f4 ld [ %fp + -12 ], %g1
if (!oname)
4000c964: 80 a0 60 00 cmp %g1, 0
4000c968: 02 80 00 0b be 4000c994 <rtems_rtl_find_obj+0xec>
<== NEVER TAKEN
4000c96c: 92 10 20 00 clr %o1
}
4000c970: 81 c7 e0 08 ret
4000c974: 81 e8 00 00 restore
if (!aname)
4000c978: 80 a7 60 00 cmp %i5, 0
<== NOT EXECUTED
4000c97c: 02 80 00 0c be 4000c9ac <rtems_rtl_find_obj+0x104>
<== ALWAYS TAKEN
4000c980: c2 07 bf f4 ld [ %fp + -12 ], %g1
if (!oname)
4000c984: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000c988: 12 bf ff fa bne 4000c970 <rtems_rtl_find_obj+0xc8>
<== NOT EXECUTED
4000c98c: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_alloc_del(RTEMS_RTL_ALLOC_OBJECT, (void*) oname);
4000c990: 92 10 20 00 clr %o1
<== NOT EXECUTED
4000c994: 7f ff f6 cd call 4000a4c8 <rtems_rtl_alloc_del>
<== NOT EXECUTED
4000c998: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000c99c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c9a0: 81 e8 00 00 restore
<== NOT EXECUTED
}
4000c9a4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c9a8: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
4000c9ac: 10 bf ff ea b 4000c954 <rtems_rtl_find_obj+0xac>
4000c9b0: b0 10 20 00 clr %i0
4000be34 <rtems_rtl_get_error>:
int
rtems_rtl_get_error (char* message, size_t max_message)
{
4000be34: 9d e3 bf a0 save %sp, -96, %sp
rtems_rtl_data* rtl = rtems_rtl_lock ();
4000be38: 40 00 01 7f call 4000c434 <rtems_rtl_lock>
4000be3c: 01 00 00 00 nop
if (rtl != NULL)
4000be40: 80 a2 20 00 cmp %o0, 0
4000be44: 02 80 00 0a be 4000be6c <rtems_rtl_get_error+0x38>
<== NEVER TAKEN
4000be48: 94 10 00 19 mov %i1, %o2
{
int last_errno = rtl->last_errno;
strlcpy (message, rtl->last_error, max_message);
4000be4c: 92 02 21 24 add %o0, 0x124, %o1
int last_errno = rtl->last_errno;
4000be50: fa 02 21 20 ld [ %o0 + 0x120 ], %i5
strlcpy (message, rtl->last_error, max_message);
4000be54: 40 00 43 67 call 4001cbf0 <strlcpy>
4000be58: 90 10 00 18 mov %i0, %o0
rtems_rtl_unlock ();
4000be5c: 40 00 02 7b call 4000c848 <rtems_rtl_unlock>
4000be60: b0 10 00 1d mov %i5, %i0
}
strncpy(message, "RTL init error", max_message);
return EIO;
}
4000be64: 81 c7 e0 08 ret
4000be68: 81 e8 00 00 restore
strncpy(message, "RTL init error", max_message);
4000be6c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
return EIO;
4000be70: ba 10 20 05 mov 5, %i5
<== NOT EXECUTED
strncpy(message, "RTL init error", max_message);
4000be74: 13 10 00 c2 sethi %hi(0x40030800), %o1
<== NOT EXECUTED
}
4000be78: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
strncpy(message, "RTL init error", max_message);
4000be7c: 40 00 43 f2 call 4001ce44 <strncpy>
<== NOT EXECUTED
4000be80: 92 12 62 a0 or %o1, 0x2a0, %o1
<== NOT EXECUTED
}
4000be84: 81 c7 e0 08 ret
<== NOT EXECUTED
4000be88: 81 e8 00 00 restore
<== NOT EXECUTED
4000c2ec <rtems_rtl_global_symbols>:
return rtl;
}
rtems_rtl_symbols*
rtems_rtl_global_symbols (void)
{
4000c2ec: 9d e3 bf a0 save %sp, -96, %sp
if (!rtl)
4000c2f0: 03 10 00 d8 sethi %hi(0x40036000), %g1
4000c2f4: c2 00 61 e4 ld [ %g1 + 0x1e4 ], %g1 ! 400361e4 <rtl>
4000c2f8: 80 a0 60 00 cmp %g1, 0
4000c2fc: 12 80 00 07 bne 4000c318 <rtems_rtl_global_symbols+0x2c>
<== ALWAYS TAKEN
4000c300: b0 00 60 74 add %g1, 0x74, %i0
{
rtems_rtl_set_error (ENOENT, "no rtl");
4000c304: 90 10 20 02 mov 2, %o0
<== NOT EXECUTED
4000c308: 13 10 00 c3 sethi %hi(0x40030c00), %o1
<== NOT EXECUTED
return NULL;
4000c30c: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (ENOENT, "no rtl");
4000c310: 7f ff fe b7 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000c314: 92 12 61 c8 or %o1, 0x1c8, %o1
<== NOT EXECUTED
}
return &rtl->globals;
}
4000c318: 81 c7 e0 08 ret
4000c31c: 81 e8 00 00 restore
4000c9b4 <rtems_rtl_load_object>:
{
4000c9b4: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD))
4000c9b8: 40 00 0f 13 call 40010604 <rtems_rtl_trace>
4000c9bc: 90 10 20 04 mov 4, %o0
4000c9c0: 80 a2 20 00 cmp %o0, 0
4000c9c4: 12 80 00 0e bne 4000c9fc <rtems_rtl_load_object+0x48>
4000c9c8: 92 10 00 18 mov %i0, %o1
obj = rtems_rtl_find_obj (name);
4000c9cc: 7f ff ff b7 call 4000c8a8 <rtems_rtl_find_obj>
4000c9d0: 90 10 00 18 mov %i0, %o0
if (!obj)
4000c9d4: ba 92 20 00 orcc %o0, 0, %i5
4000c9d8: 02 80 00 11 be 4000ca1c <rtems_rtl_load_object+0x68>
<== ALWAYS TAKEN
4000c9dc: 01 00 00 00 nop
++obj->users;
4000c9e0: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
4000c9e4: 82 00 60 01 inc %g1
<== NOT EXECUTED
if (obj->users == 1)
4000c9e8: 80 a0 60 01 cmp %g1, 1
<== NOT EXECUTED
4000c9ec: 02 80 00 28 be 4000ca8c <rtems_rtl_load_object+0xd8>
<== NOT EXECUTED
4000c9f0: c2 27 60 0c st %g1, [ %i5 + 0xc ]
<== NOT EXECUTED
}
4000c9f4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c9f8: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
printf ("rtl: loading '%s'\n", name);
4000c9fc: 11 10 00 c3 sethi %hi(0x40030c00), %o0
4000ca00: 40 00 2f d2 call 40018948 <__wrap_printf>
4000ca04: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 40030df0 <reloc_target_flags+0x88>
obj = rtems_rtl_find_obj (name);
4000ca08: 7f ff ff a8 call 4000c8a8 <rtems_rtl_find_obj>
4000ca0c: 90 10 00 18 mov %i0, %o0
if (!obj)
4000ca10: ba 92 20 00 orcc %o0, 0, %i5
4000ca14: 32 bf ff f4 bne,a 4000c9e4 <rtems_rtl_load_object+0x30>
<== NEVER TAKEN
4000ca18: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
obj = rtems_rtl_obj_alloc ();
4000ca1c: 40 00 04 39 call 4000db00 <rtems_rtl_obj_alloc>
4000ca20: 01 00 00 00 nop
if (obj == NULL)
4000ca24: b8 92 20 00 orcc %o0, 0, %i4
4000ca28: 22 80 00 2d be,a 4000cadc <rtems_rtl_load_object+0x128>
<== NEVER TAKEN
4000ca2c: 90 10 20 0c mov 0xc, %o0
<== NOT EXECUTED
if (!rtems_rtl_obj_find_file (obj, name))
4000ca30: 40 00 06 aa call 4000e4d8 <rtems_rtl_obj_find_file>
4000ca34: 92 10 00 18 mov %i0, %o1
4000ca38: 80 a2 20 00 cmp %o0, 0
4000ca3c: 02 80 00 23 be 4000cac8 <rtems_rtl_load_object+0x114>
<== NEVER TAKEN
4000ca40: 03 10 00 d8 sethi %hi(0x40036000), %g1
rtems_chain_append (&rtl->objects, &obj->link);
4000ca44: d0 00 61 e4 ld [ %g1 + 0x1e4 ], %o0 ! 400361e4 <rtl>
4000ca48: 92 10 00 1c mov %i4, %o1
4000ca4c: 40 00 15 cb call 40012178 <rtems_chain_append>
4000ca50: 90 02 20 64 add %o0, 0x64, %o0
if (!rtems_rtl_obj_load (obj))
4000ca54: 40 00 08 81 call 4000ec58 <rtems_rtl_obj_load>
4000ca58: 90 10 00 1c mov %i4, %o0
4000ca5c: 80 a2 20 00 cmp %o0, 0
4000ca60: 02 80 00 1a be 4000cac8 <rtems_rtl_load_object+0x114>
<== NEVER TAKEN
4000ca64: 01 00 00 00 nop
rtems_rtl_obj_caches_flush ();
4000ca68: 7f ff fe 57 call 4000c3c4 <rtems_rtl_obj_caches_flush>
4000ca6c: ba 10 00 1c mov %i4, %i5
rtems_rtl_unresolved_resolve ();
4000ca70: 40 00 10 99 call 40010cd4 <rtems_rtl_unresolved_resolve>
4000ca74: 01 00 00 00 nop
++obj->users;
4000ca78: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000ca7c: 82 00 60 01 inc %g1
if (obj->users == 1)
4000ca80: 80 a0 60 01 cmp %g1, 1
4000ca84: 12 bf ff dc bne 4000c9f4 <rtems_rtl_load_object+0x40>
<== NEVER TAKEN
4000ca88: c2 27 60 0c st %g1, [ %i5 + 0xc ]
obj->flags |= RTEMS_RTL_OBJ_LOCKED;
4000ca8c: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000ca90: 82 10 60 01 or %g1, 1, %g1
4000ca94: c2 27 60 08 st %g1, [ %i5 + 8 ]
rtems_recursive_mutex_unlock (&rtl->lock);
4000ca98: 03 10 00 d8 sethi %hi(0x40036000), %g1
4000ca9c: 40 00 1e e1 call 40014620 <_Mutex_recursive_Release>
4000caa0: d0 00 61 e4 ld [ %g1 + 0x1e4 ], %o0 ! 400361e4 <rtl>
rtems_rtl_obj_run_ctors (obj);
4000caa4: 40 00 08 65 call 4000ec38 <rtems_rtl_obj_run_ctors>
4000caa8: 90 10 00 1d mov %i5, %o0
rtems_rtl_lock ();
4000caac: 7f ff fe 62 call 4000c434 <rtems_rtl_lock>
4000cab0: b0 10 00 1d mov %i5, %i0
obj->flags &= ~RTEMS_RTL_OBJ_LOCKED;
4000cab4: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000cab8: 82 08 7f fe and %g1, -2, %g1
4000cabc: c2 27 60 08 st %g1, [ %i5 + 8 ]
}
4000cac0: 81 c7 e0 08 ret
4000cac4: 81 e8 00 00 restore
rtems_rtl_obj_free (obj);
4000cac8: 40 00 04 1e call 4000db40 <rtems_rtl_obj_free>
<== NOT EXECUTED
4000cacc: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
rtems_rtl_obj_caches_flush ();
4000cad0: 7f ff fe 3d call 4000c3c4 <rtems_rtl_obj_caches_flush>
<== NOT EXECUTED
4000cad4: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
return NULL;
4000cad8: 30 bf ff fa b,a 4000cac0 <rtems_rtl_load_object+0x10c>
<== NOT EXECUTED
rtems_rtl_set_error (ENOMEM, "no memory for object descriptor");
4000cadc: 13 10 00 c3 sethi %hi(0x40030c00), %o1
<== NOT EXECUTED
4000cae0: 7f ff fc c3 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000cae4: 92 12 62 08 or %o1, 0x208, %o1 ! 40030e08 <reloc_target_flags+0xa0>
<== NOT EXECUTED
return NULL;
4000cae8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000caec: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
4000c434 <rtems_rtl_lock>:
rtems_rtl_data*
rtems_rtl_lock (void)
{
4000c434: 9d e3 bf a0 save %sp, -96, %sp
if (!rtl)
4000c438: 3b 10 00 d8 sethi %hi(0x40036000), %i5
4000c43c: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0 ! 400361e4 <rtl>
4000c440: 80 a2 20 00 cmp %o0, 0
4000c444: 02 80 00 07 be 4000c460 <rtems_rtl_lock+0x2c>
4000c448: 01 00 00 00 nop
static __inline void rtems_recursive_mutex_lock(
rtems_recursive_mutex *mutex
)
{
_Mutex_recursive_Acquire( mutex );
4000c44c: 40 00 20 50 call 4001458c <_Mutex_recursive_Acquire>
4000c450: 01 00 00 00 nop
if (!rtems_rtl_data_init ())
return NULL;
rtems_recursive_mutex_lock (&rtl->lock);
return rtl;
4000c454: f0 07 61 e4 ld [ %i5 + 0x1e4 ], %i0
}
4000c458: 81 c7 e0 08 ret
4000c45c: 81 e8 00 00 restore
rtems_libio_lock ();
4000c460: 7f ff ed 1c call 400078d0 <rtems_libio_lock>
4000c464: 01 00 00 00 nop
if (!rtl)
4000c468: f0 07 61 e4 ld [ %i5 + 0x1e4 ], %i0
4000c46c: 80 a6 20 00 cmp %i0, 0
4000c470: 02 80 00 11 be 4000c4b4 <rtems_rtl_lock+0x80>
<== ALWAYS TAKEN
4000c474: 03 10 00 d8 sethi %hi(0x40036000), %g1
rtems_libio_unlock ();
4000c478: 7f ff ed 1b call 400078e4 <rtems_libio_unlock>
4000c47c: 01 00 00 00 nop
}
bool
rtems_rtl_path_append (const char* path)
{
return rtems_rtl_path_update (false, path);
4000c480: 90 10 20 00 clr %o0 ! 0 <PROM_START>
4000c484: 13 10 00 c1 sethi %hi(0x40030400), %o1
4000c488: 40 00 00 91 call 4000c6cc <rtems_rtl_path_update>
4000c48c: 92 12 61 20 or %o1, 0x120, %o1 ! 40030520 <rtems_filesystem_default_pathconf+0x30>
rtems_rtl_base_global_syms_init ();
4000c490: 7f ff d3 eb call 4000143c <rtems_rtl_base_global_syms_init>
4000c494: 01 00 00 00 nop
static __inline void rtems_recursive_mutex_unlock(
rtems_recursive_mutex *mutex
)
{
_Mutex_recursive_Release( mutex );
4000c498: 40 00 20 62 call 40014620 <_Mutex_recursive_Release>
4000c49c: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0
_Mutex_recursive_Acquire( mutex );
4000c4a0: 40 00 20 3b call 4001458c <_Mutex_recursive_Acquire>
4000c4a4: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0
return rtl;
4000c4a8: f0 07 61 e4 ld [ %i5 + 0x1e4 ], %i0
}
4000c4ac: 81 c7 e0 08 ret
4000c4b0: 81 e8 00 00 restore
if (rtl_data_init)
4000c4b4: c4 08 61 e0 ldub [ %g1 + 0x1e0 ], %g2
4000c4b8: 80 a0 a0 00 cmp %g2, 0
4000c4bc: 12 80 00 56 bne 4000c614 <rtems_rtl_lock+0x1e0>
<== NEVER TAKEN
4000c4c0: 84 10 20 01 mov 1, %g2
rtl = malloc (sizeof (rtems_rtl_data));
4000c4c4: 90 10 21 68 mov 0x168, %o0
4000c4c8: 7f ff ed ff call 40007cc4 <malloc>
4000c4cc: c4 28 61 e0 stb %g2, [ %g1 + 0x1e0 ]
4000c4d0: d0 27 61 e4 st %o0, [ %i5 + 0x1e4 ]
if (!rtl)
4000c4d4: 80 a2 20 00 cmp %o0, 0
4000c4d8: 02 80 00 6a be 4000c680 <rtems_rtl_lock+0x24c>
<== NEVER TAKEN
4000c4dc: b8 10 00 08 mov %o0, %i4
*rtl = (rtems_rtl_data) { 0 };
4000c4e0: 94 10 21 68 mov 0x168, %o2
4000c4e4: 40 00 3a aa call 4001af8c <memset>
4000c4e8: 92 10 20 00 clr %o1
rtems_rtl_alloc_initialise (&rtl->allocator);
4000c4ec: 7f ff f7 c0 call 4000a3ec <rtems_rtl_alloc_initialise>
4000c4f0: 90 07 20 18 add %i4, 0x18, %o0
rtems_recursive_mutex_init (&rtl->lock, "Run-Time Linker");
4000c4f4: c2 07 61 e4 ld [ %i5 + 0x1e4 ], %g1
const char *_name)
{
struct _Mutex_recursive_Control _init =
_MUTEX_RECURSIVE_NAMED_INITIALIZER(_name);
*_mutex = _init;
4000c4f8: c0 20 40 00 clr [ %g1 ]
4000c4fc: 05 10 00 c3 sethi %hi(0x40030c00), %g2
4000c500: c0 20 60 04 clr [ %g1 + 4 ]
4000c504: 84 10 a1 d0 or %g2, 0x1d0, %g2
4000c508: c0 20 60 08 clr [ %g1 + 8 ]
4000c50c: 90 10 00 01 mov %g1, %o0
4000c510: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
4000c514: c0 20 60 0c clr [ %g1 + 0xc ]
4000c518: 40 00 20 1d call 4001458c <_Mutex_recursive_Acquire>
4000c51c: c0 20 60 14 clr [ %g1 + 0x14 ]
rtems_chain_initialize_empty (&rtl->objects);
4000c520: c2 07 61 e4 ld [ %i5 + 0x1e4 ], %g1
return &the_chain->Tail.Node;
4000c524: 84 00 60 64 add %g1, 0x64, %g2
4000c528: 86 00 60 68 add %g1, 0x68, %g3
head->previous = NULL;
4000c52c: c0 20 60 68 clr [ %g1 + 0x68 ]
if (!rtems_rtl_symbol_table_open (&rtl->globals,
4000c530: 92 10 20 20 mov 0x20, %o1
head->next = tail;
4000c534: c6 20 60 64 st %g3, [ %g1 + 0x64 ]
4000c538: 90 00 60 74 add %g1, 0x74, %o0
4000c53c: 40 00 0e c1 call 40010040 <rtems_rtl_symbol_table_open>
4000c540: c4 20 60 6c st %g2, [ %g1 + 0x6c ]
4000c544: 80 a2 20 00 cmp %o0, 0
4000c548: 02 80 00 31 be 4000c60c <rtems_rtl_lock+0x1d8>
<== NEVER TAKEN
4000c54c: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0
if (!rtems_rtl_unresolved_table_open (&rtl->unresolved,
4000c550: 92 10 20 40 mov 0x40, %o1
4000c554: 40 00 10 a8 call 400107f4 <rtems_rtl_unresolved_table_open>
4000c558: 90 02 20 7c add %o0, 0x7c, %o0
4000c55c: 80 a2 20 00 cmp %o0, 0
4000c560: 02 80 00 40 be 4000c660 <rtems_rtl_lock+0x22c>
<== NEVER TAKEN
4000c564: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0
if (!rtems_rtl_obj_cache_open (&rtl->symbols,
4000c568: 92 10 28 00 mov 0x800, %o1
4000c56c: 40 00 01 bd call 4000cc60 <rtems_rtl_obj_cache_open>
4000c570: 90 02 20 98 add %o0, 0x98, %o0
4000c574: 80 a2 20 00 cmp %o0, 0
4000c578: 02 80 00 4a be 4000c6a0 <rtems_rtl_lock+0x26c>
<== NEVER TAKEN
4000c57c: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0
if (!rtems_rtl_obj_cache_open (&rtl->strings,
4000c580: 92 10 28 00 mov 0x800, %o1
4000c584: 40 00 01 b7 call 4000cc60 <rtems_rtl_obj_cache_open>
4000c588: 90 02 20 b8 add %o0, 0xb8, %o0
4000c58c: 80 a2 20 00 cmp %o0, 0
4000c590: 02 80 00 2e be 4000c648 <rtems_rtl_lock+0x214>
<== NEVER TAKEN
4000c594: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0
if (!rtems_rtl_obj_cache_open (&rtl->relocs,
4000c598: 92 10 28 00 mov 0x800, %o1
4000c59c: 40 00 01 b1 call 4000cc60 <rtems_rtl_obj_cache_open>
4000c5a0: 90 02 20 d8 add %o0, 0xd8, %o0
4000c5a4: 80 a2 20 00 cmp %o0, 0
4000c5a8: 02 80 00 25 be 4000c63c <rtems_rtl_lock+0x208>
<== NEVER TAKEN
4000c5ac: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0
if (!rtems_rtl_obj_comp_open (&rtl->decomp,
4000c5b0: 92 10 28 00 mov 0x800, %o1
4000c5b4: 40 00 03 3d call 4000d2a8 <rtems_rtl_obj_comp_open>
4000c5b8: 90 02 20 f8 add %o0, 0xf8, %o0
4000c5bc: 80 a2 20 00 cmp %o0, 0
4000c5c0: 02 80 00 1c be 4000c630 <rtems_rtl_lock+0x1fc>
<== NEVER TAKEN
4000c5c4: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0
rtl->base = rtems_rtl_obj_alloc ();
4000c5c8: 40 00 05 4e call 4000db00 <rtems_rtl_obj_alloc>
4000c5cc: f8 07 61 e4 ld [ %i5 + 0x1e4 ], %i4
4000c5d0: d0 27 20 90 st %o0, [ %i4 + 0x90 ]
if (!rtl->base)
4000c5d4: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0
4000c5d8: f8 02 20 90 ld [ %o0 + 0x90 ], %i4
4000c5dc: 80 a7 20 00 cmp %i4, 0
4000c5e0: 02 80 00 11 be 4000c624 <rtems_rtl_lock+0x1f0>
<== NEVER TAKEN
4000c5e4: 01 00 00 00 nop
rtl->base->oname = rtems_rtl_strdup ("rtems-kernel");
4000c5e8: 11 10 00 c3 sethi %hi(0x40030c00), %o0
4000c5ec: 40 00 0e 67 call 4000ff88 <rtems_rtl_strdup>
4000c5f0: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 40030de0 <reloc_target_flags+0x78>
rtems_chain_append (&rtl->objects, &rtl->base->link);
4000c5f4: c2 07 61 e4 ld [ %i5 + 0x1e4 ], %g1
rtl->base->oname = rtems_rtl_strdup ("rtems-kernel");
4000c5f8: d0 27 20 18 st %o0, [ %i4 + 0x18 ]
rtems_chain_append (&rtl->objects, &rtl->base->link);
4000c5fc: 90 00 60 64 add %g1, 0x64, %o0
4000c600: 40 00 16 de call 40012178 <rtems_chain_append>
4000c604: d2 00 60 90 ld [ %g1 + 0x90 ], %o1
4000c608: 30 bf ff 9c b,a 4000c478 <rtems_rtl_lock+0x44>
free (rtl);
4000c60c: 7f ff eb b2 call 400074d4 <free>
<== NOT EXECUTED
4000c610: 01 00 00 00 nop
<== NOT EXECUTED
rtems_libio_unlock ();
4000c614: 7f ff ec b4 call 400078e4 <rtems_libio_unlock>
<== NOT EXECUTED
4000c618: 01 00 00 00 nop
<== NOT EXECUTED
4000c61c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c620: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rtl_obj_comp_close (&rtl->decomp);
4000c624: 40 00 03 3f call 4000d320 <rtems_rtl_obj_comp_close>
<== NOT EXECUTED
4000c628: 90 02 20 f8 add %o0, 0xf8, %o0
<== NOT EXECUTED
rtems_rtl_obj_cache_close (&rtl->relocs);
4000c62c: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0
<== NOT EXECUTED
4000c630: 40 00 01 a7 call 4000cccc <rtems_rtl_obj_cache_close>
<== NOT EXECUTED
4000c634: 90 02 20 d8 add %o0, 0xd8, %o0
<== NOT EXECUTED
rtems_rtl_obj_cache_close (&rtl->strings);
4000c638: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0
<== NOT EXECUTED
4000c63c: 40 00 01 a4 call 4000cccc <rtems_rtl_obj_cache_close>
<== NOT EXECUTED
4000c640: 90 02 20 b8 add %o0, 0xb8, %o0
<== NOT EXECUTED
rtems_rtl_obj_cache_close (&rtl->symbols);
4000c644: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0
<== NOT EXECUTED
4000c648: 40 00 01 a1 call 4000cccc <rtems_rtl_obj_cache_close>
<== NOT EXECUTED
4000c64c: 90 02 20 98 add %o0, 0x98, %o0
<== NOT EXECUTED
rtems_rtl_unresolved_table_close (&rtl->unresolved);
4000c650: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0
<== NOT EXECUTED
4000c654: 40 00 10 74 call 40010824 <rtems_rtl_unresolved_table_close>
<== NOT EXECUTED
4000c658: 90 02 20 7c add %o0, 0x7c, %o0
<== NOT EXECUTED
rtems_rtl_symbol_table_close (&rtl->globals);
4000c65c: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0
<== NOT EXECUTED
4000c660: 40 00 0e a0 call 400100e0 <rtems_rtl_symbol_table_close>
<== NOT EXECUTED
4000c664: 90 02 20 74 add %o0, 0x74, %o0
<== NOT EXECUTED
free (rtl);
4000c668: 7f ff eb 9b call 400074d4 <free>
<== NOT EXECUTED
4000c66c: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0
<== NOT EXECUTED
rtems_libio_unlock ();
4000c670: 7f ff ec 9d call 400078e4 <rtems_libio_unlock>
<== NOT EXECUTED
4000c674: 01 00 00 00 nop
<== NOT EXECUTED
4000c678: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c67c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_libio_unlock ();
4000c680: 7f ff ec 99 call 400078e4 <rtems_libio_unlock>
<== NOT EXECUTED
4000c684: 01 00 00 00 nop
<== NOT EXECUTED
errno = ENOMEM;
4000c688: 40 00 38 bb call 4001a974 <__errno>
<== NOT EXECUTED
4000c68c: 01 00 00 00 nop
<== NOT EXECUTED
4000c690: 82 10 20 0c mov 0xc, %g1 ! c <_TLS_Alignment+0xb>
<== NOT EXECUTED
4000c694: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000c698: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c69c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rtl_symbol_table_close (&rtl->globals);
4000c6a0: 40 00 0e 90 call 400100e0 <rtems_rtl_symbol_table_close>
<== NOT EXECUTED
4000c6a4: 90 02 20 74 add %o0, 0x74, %o0
<== NOT EXECUTED
rtems_rtl_unresolved_table_close (&rtl->unresolved);
4000c6a8: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0
<== NOT EXECUTED
4000c6ac: 40 00 10 5e call 40010824 <rtems_rtl_unresolved_table_close>
<== NOT EXECUTED
4000c6b0: 90 02 20 7c add %o0, 0x7c, %o0
<== NOT EXECUTED
free (rtl);
4000c6b4: 7f ff eb 88 call 400074d4 <free>
<== NOT EXECUTED
4000c6b8: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0
<== NOT EXECUTED
rtems_libio_unlock ();
4000c6bc: 7f ff ec 8a call 400078e4 <rtems_libio_unlock>
<== NOT EXECUTED
4000c6c0: 01 00 00 00 nop
<== NOT EXECUTED
4000c6c4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c6c8: 81 e8 00 00 restore
<== NOT EXECUTED
4000dde8 <rtems_rtl_match_name>:
const char* n1 = obj->oname;
4000dde8: c8 02 20 18 ld [ %o0 + 0x18 ], %g4
<== NOT EXECUTED
while ((*n1 != '\0') && (*n1 != '\n') && (*n1 != '/') &&
4000ddec: c4 09 00 00 ldub [ %g4 ], %g2
<== NOT EXECUTED
4000ddf0: 85 28 a0 18 sll %g2, 0x18, %g2
<== NOT EXECUTED
4000ddf4: 87 38 a0 18 sra %g2, 0x18, %g3
<== NOT EXECUTED
4000ddf8: 80 a0 e0 0a cmp %g3, 0xa
<== NOT EXECUTED
4000ddfc: 02 80 00 3c be 4000deec <rtems_rtl_match_name+0x104>
<== NOT EXECUTED
4000de00: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
4000de04: 02 80 00 3a be 4000deec <rtems_rtl_match_name+0x104>
<== NOT EXECUTED
4000de08: 80 a0 e0 2f cmp %g3, 0x2f
<== NOT EXECUTED
4000de0c: 02 80 00 2e be 4000dec4 <rtems_rtl_match_name+0xdc>
<== NOT EXECUTED
4000de10: c2 0a 40 00 ldub [ %o1 ], %g1
<== NOT EXECUTED
4000de14: 83 28 60 18 sll %g1, 0x18, %g1
<== NOT EXECUTED
4000de18: 83 38 60 18 sra %g1, 0x18, %g1
<== NOT EXECUTED
4000de1c: 80 a0 00 01 cmp %g0, %g1
<== NOT EXECUTED
(*name != '\0') && (*name != '/') && (*n1 == *name))
4000de20: 9a 18 60 2f xor %g1, 0x2f, %o5
<== NOT EXECUTED
while ((*n1 != '\0') && (*n1 != '\n') && (*n1 != '/') &&
4000de24: 84 40 20 00 addx %g0, 0, %g2
<== NOT EXECUTED
(*name != '\0') && (*name != '/') && (*n1 == *name))
4000de28: 80 a0 00 0d cmp %g0, %o5
<== NOT EXECUTED
4000de2c: 82 18 c0 01 xor %g3, %g1, %g1
<== NOT EXECUTED
4000de30: 86 40 20 00 addx %g0, 0, %g3
<== NOT EXECUTED
4000de34: 80 a0 00 01 cmp %g0, %g1
<== NOT EXECUTED
4000de38: 84 08 80 03 and %g2, %g3, %g2
<== NOT EXECUTED
4000de3c: 82 60 3f ff subx %g0, -1, %g1
<== NOT EXECUTED
4000de40: 82 08 40 02 and %g1, %g2, %g1
<== NOT EXECUTED
4000de44: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000de48: 02 80 00 1d be 4000debc <rtems_rtl_match_name+0xd4>
<== NOT EXECUTED
4000de4c: 90 10 00 01 mov %g1, %o0
<== NOT EXECUTED
++n1;
4000de50: 88 01 20 01 inc %g4
<== NOT EXECUTED
while ((*n1 != '\0') && (*n1 != '\n') && (*n1 != '/') &&
4000de54: c4 09 00 00 ldub [ %g4 ], %g2
<== NOT EXECUTED
4000de58: 85 28 a0 18 sll %g2, 0x18, %g2
<== NOT EXECUTED
4000de5c: 83 38 a0 18 sra %g2, 0x18, %g1
<== NOT EXECUTED
4000de60: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000de64: 02 80 00 23 be 4000def0 <rtems_rtl_match_name+0x108>
<== NOT EXECUTED
4000de68: 9a 02 60 01 add %o1, 1, %o5
<== NOT EXECUTED
4000de6c: 80 a0 60 0a cmp %g1, 0xa
<== NOT EXECUTED
4000de70: 02 80 00 20 be 4000def0 <rtems_rtl_match_name+0x108>
<== NOT EXECUTED
4000de74: 80 a0 60 2f cmp %g1, 0x2f
<== NOT EXECUTED
4000de78: 22 80 00 13 be,a 4000dec4 <rtems_rtl_match_name+0xdc>
<== NOT EXECUTED
4000de7c: c2 0a 60 01 ldub [ %o1 + 1 ], %g1
<== NOT EXECUTED
4000de80: c6 4b 40 00 ldsb [ %o5 ], %g3
<== NOT EXECUTED
4000de84: 80 a0 00 03 cmp %g0, %g3
<== NOT EXECUTED
(*name != '\0') && (*name != '/') && (*n1 == *name))
4000de88: 98 18 e0 2f xor %g3, 0x2f, %o4
<== NOT EXECUTED
while ((*n1 != '\0') && (*n1 != '\n') && (*n1 != '/') &&
4000de8c: 84 40 20 00 addx %g0, 0, %g2
<== NOT EXECUTED
(*name != '\0') && (*name != '/') && (*n1 == *name))
4000de90: 80 a0 00 0c cmp %g0, %o4
<== NOT EXECUTED
4000de94: 82 18 40 03 xor %g1, %g3, %g1
<== NOT EXECUTED
4000de98: 86 40 20 00 addx %g0, 0, %g3
<== NOT EXECUTED
4000de9c: 80 a0 00 01 cmp %g0, %g1
<== NOT EXECUTED
4000dea0: 84 08 80 03 and %g2, %g3, %g2
<== NOT EXECUTED
4000dea4: 82 60 3f ff subx %g0, -1, %g1
<== NOT EXECUTED
4000dea8: 92 10 00 0d mov %o5, %o1
<== NOT EXECUTED
4000deac: 82 08 40 02 and %g1, %g2, %g1
<== NOT EXECUTED
4000deb0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000deb4: 12 bf ff e7 bne 4000de50 <rtems_rtl_match_name+0x68>
<== NOT EXECUTED
4000deb8: 90 10 00 01 mov %g1, %o0
<== NOT EXECUTED
}
4000debc: 81 c3 e0 08 retl
<== NOT EXECUTED
4000dec0: 90 0a 20 01 and %o0, 1, %o0
<== NOT EXECUTED
((*name == '\0') || (*name == '/')))
4000dec4: 83 28 60 18 sll %g1, 0x18, %g1
<== NOT EXECUTED
4000dec8: 83 38 60 18 sra %g1, 0x18, %g1
<== NOT EXECUTED
4000decc: 80 a0 00 01 cmp %g0, %g1
<== NOT EXECUTED
4000ded0: 82 18 60 2f xor %g1, 0x2f, %g1
<== NOT EXECUTED
4000ded4: 90 60 3f ff subx %g0, -1, %o0
<== NOT EXECUTED
4000ded8: 80 a0 00 01 cmp %g0, %g1
<== NOT EXECUTED
4000dedc: 82 60 3f ff subx %g0, -1, %g1
<== NOT EXECUTED
4000dee0: 90 12 00 01 or %o0, %g1, %o0
<== NOT EXECUTED
}
4000dee4: 81 c3 e0 08 retl
<== NOT EXECUTED
4000dee8: 90 0a 20 01 and %o0, 1, %o0
<== NOT EXECUTED
while ((*n1 != '\0') && (*n1 != '\n') && (*n1 != '/') &&
4000deec: 9a 10 00 09 mov %o1, %o5
<== NOT EXECUTED
if (((*n1 == '\0') || (*n1 == '\n') || (*n1 == '/')) &&
4000def0: 85 38 a0 18 sra %g2, 0x18, %g2
<== NOT EXECUTED
4000def4: 80 a0 00 02 cmp %g0, %g2
<== NOT EXECUTED
4000def8: 86 18 a0 0a xor %g2, 0xa, %g3
<== NOT EXECUTED
4000defc: 82 60 3f ff subx %g0, -1, %g1
<== NOT EXECUTED
4000df00: 80 a0 00 03 cmp %g0, %g3
<== NOT EXECUTED
4000df04: 86 60 3f ff subx %g0, -1, %g3
<== NOT EXECUTED
4000df08: 82 10 40 03 or %g1, %g3, %g1
<== NOT EXECUTED
4000df0c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
4000df10: 02 80 00 0c be 4000df40 <rtems_rtl_match_name+0x158>
<== NOT EXECUTED
4000df14: 90 10 00 01 mov %g1, %o0
<== NOT EXECUTED
4000df18: c2 0b 40 00 ldub [ %o5 ], %g1
<== NOT EXECUTED
((*name == '\0') || (*name == '/')))
4000df1c: 83 28 60 18 sll %g1, 0x18, %g1
<== NOT EXECUTED
4000df20: 83 38 60 18 sra %g1, 0x18, %g1
<== NOT EXECUTED
4000df24: 80 a0 00 01 cmp %g0, %g1
<== NOT EXECUTED
4000df28: 82 18 60 2f xor %g1, 0x2f, %g1
<== NOT EXECUTED
4000df2c: 90 60 3f ff subx %g0, -1, %o0
<== NOT EXECUTED
4000df30: 80 a0 00 01 cmp %g0, %g1
<== NOT EXECUTED
4000df34: 82 60 3f ff subx %g0, -1, %g1
<== NOT EXECUTED
4000df38: 10 bf ff eb b 4000dee4 <rtems_rtl_match_name+0xfc>
<== NOT EXECUTED
4000df3c: 90 12 00 01 or %o0, %g1, %o0
<== NOT EXECUTED
if (((*n1 == '\0') || (*n1 == '\n') || (*n1 == '/')) &&
4000df40: 80 a0 a0 2f cmp %g2, 0x2f
<== NOT EXECUTED
4000df44: 12 bf ff de bne 4000debc <rtems_rtl_match_name+0xd4>
<== NOT EXECUTED
4000df48: 01 00 00 00 nop
<== NOT EXECUTED
4000df4c: 10 bf ff f4 b 4000df1c <rtems_rtl_match_name+0x134>
<== NOT EXECUTED
4000df50: c2 0b 40 00 ldub [ %o5 ], %g1
<== NOT EXECUTED
4000e59c <rtems_rtl_obj_add_section>:
{
4000e59c: 9d e3 bf a0 save %sp, -96, %sp
4000e5a0: a0 10 00 1c mov %i4, %l0
if (size > 0)
4000e5a4: 80 a6 e0 00 cmp %i3, 0
4000e5a8: 12 80 00 06 bne 4000e5c0 <rtems_rtl_obj_add_section+0x24>
4000e5ac: a2 10 00 1d mov %i5, %l1
return true;
4000e5b0: b0 10 20 01 mov 1, %i0
}
4000e5b4: b0 0e 20 ff and %i0, 0xff, %i0
4000e5b8: 81 c7 e0 08 ret
4000e5bc: 81 e8 00 00 restore
rtems_rtl_obj_sect* sect = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_OBJECT,
4000e5c0: 94 10 20 01 mov 1, %o2
4000e5c4: 92 10 20 38 mov 0x38, %o1
4000e5c8: 7f ff ef 97 call 4000a424 <rtems_rtl_alloc_new>
4000e5cc: 90 10 20 00 clr %o0
if (!sect)
4000e5d0: ba 92 20 00 orcc %o0, 0, %i5
4000e5d4: 22 80 00 22 be,a 4000e65c <rtems_rtl_obj_add_section+0xc0>
<== NEVER TAKEN
4000e5d8: 90 10 20 0c mov 0xc, %o0
<== NOT EXECUTED
sect->section = section;
4000e5dc: f2 27 60 08 st %i1, [ %i5 + 8 ]
sect->name = rtems_rtl_strdup (name);
4000e5e0: 40 00 06 6a call 4000ff88 <rtems_rtl_strdup>
4000e5e4: 90 10 00 1a mov %i2, %o0
sect->alignment = alignment;
4000e5e8: c2 07 a0 5c ld [ %fp + 0x5c ], %g1
4000e5ec: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_chain_append (&obj->sections, §->node);
4000e5f0: 92 10 00 1d mov %i5, %o1
sect->link = link;
4000e5f4: c2 07 a0 60 ld [ %fp + 0x60 ], %g1
4000e5f8: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
sect->info = info;
4000e5fc: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
4000e600: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
sect->flags = flags;
4000e604: c2 07 a0 68 ld [ %fp + 0x68 ], %g1
sect->name = rtems_rtl_strdup (name);
4000e608: d0 27 60 0c st %o0, [ %i5 + 0xc ]
rtems_chain_append (&obj->sections, §->node);
4000e60c: 90 06 20 2c add %i0, 0x2c, %o0
sect->flags = flags;
4000e610: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
sect->size = size;
4000e614: f6 27 60 10 st %i3, [ %i5 + 0x10 ]
sect->offset = offset;
4000e618: e0 3f 60 18 std %l0, [ %i5 + 0x18 ]
rtems_chain_append (&obj->sections, §->node);
4000e61c: 40 00 0e d7 call 40012178 <rtems_chain_append>
4000e620: c0 27 60 30 clr [ %i5 + 0x30 ]
if (rtems_rtl_trace (RTEMS_RTL_TRACE_SECTION))
4000e624: 40 00 07 f8 call 40010604 <rtems_rtl_trace>
4000e628: 90 10 20 10 mov 0x10, %o0
4000e62c: 80 a2 20 00 cmp %o0, 0
4000e630: 02 bf ff e0 be 4000e5b0 <rtems_rtl_obj_add_section+0x14>
4000e634: b0 10 00 08 mov %o0, %i0
printf ("rtl: sect: %-2d: %s (%zu)\n", section, name, size);
4000e638: 96 10 00 1b mov %i3, %o3
4000e63c: 94 10 00 1a mov %i2, %o2
4000e640: 92 10 00 19 mov %i1, %o1
4000e644: 11 10 00 c4 sethi %hi(0x40031000), %o0
4000e648: 40 00 28 c0 call 40018948 <__wrap_printf>
4000e64c: 90 12 23 78 or %o0, 0x378, %o0 ! 40031378 <reloc_target_flags+0x610>
4000e650: b0 0e 20 ff and %i0, 0xff, %i0
4000e654: 81 c7 e0 08 ret
4000e658: 81 e8 00 00 restore
rtems_rtl_set_error (ENOMEM, "adding allocated section");
4000e65c: 13 10 00 c4 sethi %hi(0x40031000), %o1
<== NOT EXECUTED
return false;
4000e660: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (ENOMEM, "adding allocated section");
4000e664: 7f ff f5 e2 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000e668: 92 12 63 58 or %o1, 0x358, %o1
<== NOT EXECUTED
4000e66c: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
4000e670: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e674: 81 e8 00 00 restore
<== NOT EXECUTED
4000db00 <rtems_rtl_obj_alloc>:
{
4000db00: 9d e3 bf a0 save %sp, -96, %sp
rtems_rtl_obj* obj = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_OBJECT,
4000db04: 94 10 20 01 mov 1, %o2
4000db08: 92 10 20 90 mov 0x90, %o1
4000db0c: 7f ff f2 46 call 4000a424 <rtems_rtl_alloc_new>
4000db10: 90 10 20 00 clr %o0
if (obj)
4000db14: b0 92 20 00 orcc %o0, 0, %i0
4000db18: 02 80 00 08 be 4000db38 <rtems_rtl_obj_alloc+0x38>
<== NEVER TAKEN
4000db1c: 82 06 20 2c add %i0, 0x2c, %g1
return &the_chain->Tail.Node;
4000db20: 84 06 20 30 add %i0, 0x30, %g2
tail->previous = head;
4000db24: c2 26 20 34 st %g1, [ %i0 + 0x34 ]
obj->format = -1;
4000db28: 82 10 3f ff mov -1, %g1
head->next = tail;
4000db2c: c4 26 20 2c st %g2, [ %i0 + 0x2c ]
head->previous = NULL;
4000db30: c0 26 20 30 clr [ %i0 + 0x30 ]
4000db34: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
}
4000db38: 81 c7 e0 08 ret
4000db3c: 81 e8 00 00 restore
4000cccc <rtems_rtl_obj_cache_close>:
void
rtems_rtl_obj_cache_close (rtems_rtl_obj_cache* cache)
{
4000cccc: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rtl_trace (RTEMS_RTL_TRACE_CACHE))
4000ccd0: 40 00 0e 4d call 40010604 <rtems_rtl_trace>
4000ccd4: 90 10 28 00 mov 0x800, %o0
4000ccd8: 80 a2 20 00 cmp %o0, 0
4000ccdc: 22 80 00 07 be,a 4000ccf8 <rtems_rtl_obj_cache_close+0x2c>
<== NEVER TAKEN
4000cce0: d2 06 20 18 ld [ %i0 + 0x18 ], %o1
<== NOT EXECUTED
printf ("rtl: cache: %2d: close\n", cache->fd);
4000cce4: d2 06 00 00 ld [ %i0 ], %o1
4000cce8: 11 10 00 c3 sethi %hi(0x40030c00), %o0
4000ccec: 40 00 2f 17 call 40018948 <__wrap_printf>
4000ccf0: 90 12 22 d0 or %o0, 0x2d0, %o0 ! 40030ed0 <reloc_target_flags+0x168>
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_OBJECT, cache->buffer);
4000ccf4: d2 06 20 18 ld [ %i0 + 0x18 ], %o1
4000ccf8: 7f ff f5 f4 call 4000a4c8 <rtems_rtl_alloc_del>
4000ccfc: 90 10 20 00 clr %o0
cache->buffer = NULL;
cache->fd = -1;
4000cd00: 82 10 3f ff mov -1, %g1
cache->buffer = NULL;
4000cd04: c0 26 20 18 clr [ %i0 + 0x18 ]
cache->fd = -1;
4000cd08: c2 26 00 00 st %g1, [ %i0 ]
cache->file_size = 0;
4000cd0c: c0 26 20 04 clr [ %i0 + 4 ]
cache->level = 0;
4000cd10: c0 26 20 14 clr [ %i0 + 0x14 ]
}
4000cd14: 81 c7 e0 08 ret
4000cd18: 81 e8 00 00 restore
4000cd1c <rtems_rtl_obj_cache_flush>:
void
rtems_rtl_obj_cache_flush (rtems_rtl_obj_cache* cache)
{
4000cd1c: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rtl_trace (RTEMS_RTL_TRACE_CACHE))
4000cd20: 40 00 0e 39 call 40010604 <rtems_rtl_trace>
4000cd24: 90 10 28 00 mov 0x800, %o0
4000cd28: 80 a2 20 00 cmp %o0, 0
4000cd2c: 02 80 00 07 be 4000cd48 <rtems_rtl_obj_cache_flush+0x2c>
<== ALWAYS TAKEN
4000cd30: 82 10 3f ff mov -1, %g1
printf ("rtl: cache: %2d: flush\n", cache->fd);
4000cd34: d2 06 00 00 ld [ %i0 ], %o1
<== NOT EXECUTED
4000cd38: 11 10 00 c3 sethi %hi(0x40030c00), %o0
<== NOT EXECUTED
4000cd3c: 40 00 2f 03 call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000cd40: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 40030ee8 <reloc_target_flags+0x180>
<== NOT EXECUTED
cache->fd = -1;
4000cd44: 82 10 3f ff mov -1, %g1
<== NOT EXECUTED
cache->file_size = 0;
4000cd48: c0 26 20 04 clr [ %i0 + 4 ]
cache->offset = 0;
4000cd4c: c0 26 20 08 clr [ %i0 + 8 ]
4000cd50: c0 26 20 0c clr [ %i0 + 0xc ]
cache->fd = -1;
4000cd54: c2 26 00 00 st %g1, [ %i0 ]
cache->level = 0;
4000cd58: c0 26 20 14 clr [ %i0 + 0x14 ]
}
4000cd5c: 81 c7 e0 08 ret
4000cd60: 81 e8 00 00 restore
4000cd64 <rtems_rtl_obj_cache_read>:
rtems_rtl_obj_cache_read (rtems_rtl_obj_cache* cache,
int fd,
off_t offset,
void** buffer,
size_t* length)
{
4000cd64: 9d e3 bf 10 save %sp, -240, %sp
struct stat sb;
if (rtems_rtl_trace (RTEMS_RTL_TRACE_CACHE))
4000cd68: 90 10 28 00 mov 0x800, %o0
4000cd6c: 40 00 0e 26 call 40010604 <rtems_rtl_trace>
4000cd70: a4 10 00 1a mov %i2, %l2
4000cd74: 80 a2 20 00 cmp %o0, 0
4000cd78: 12 80 00 c0 bne 4000d078 <rtems_rtl_obj_cache_read+0x314>
4000cd7c: a6 10 00 1b mov %i3, %l3
fd, cache->fd, offset, *length,
offset, offset + *length,
cache->offset, cache->offset + cache->level,
cache->file_size);
if (*length > cache->size)
4000cd80: c2 07 40 00 ld [ %i5 ], %g1
4000cd84: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
4000cd88: 80 a0 40 1b cmp %g1, %i3
4000cd8c: 18 80 00 e4 bgu 4000d11c <rtems_rtl_obj_cache_read+0x3b8>
<== NEVER TAKEN
4000cd90: 90 10 20 16 mov 0x16, %o0
{
rtems_rtl_set_error (EINVAL, "read size larger than cache size");
return false;
}
if (cache->fd == fd)
4000cd94: e8 06 00 00 ld [ %i0 ], %l4
4000cd98: 80 a5 00 19 cmp %l4, %i1
4000cd9c: 02 80 00 7c be 4000cf8c <rtems_rtl_obj_cache_read+0x228>
4000cda0: 80 a4 a0 00 cmp %l2, 0
*/
if (*length <= size)
return true;
if (rtems_rtl_trace (RTEMS_RTL_TRACE_CACHE))
printf ("rtl: cache: %2d: copy-down: buffer_offset=%d size=%d level=%d\n",
4000cda4: 2d 10 00 c3 sethi %hi(0x40030c00), %l6
buffer_read = cache->file_size - (offset + buffer_offset);
}
}
if (rtems_rtl_trace (RTEMS_RTL_TRACE_CACHE))
printf ("rtl: cache: %2d: seek: offset=%" PRIdoff_t "buffer_offset=%zu"
4000cda8: 35 10 00 c4 sethi %hi(0x40031000), %i2
return false;
}
if ((r == 0) && buffer_read)
{
if (rtems_rtl_trace (RTEMS_RTL_TRACE_CACHE))
printf ("rtl: cache: %2d: read: past end by=%d\n", fd, (int) buffer_read);
4000cdac: 23 10 00 c4 sethi %hi(0x40031000), %l1
printf ("rtl: cache: %2d: copy-down: buffer_offset=%d size=%d level=%d\n",
4000cdb0: ac 15 a3 e0 or %l6, 0x3e0, %l6
printf ("rtl: cache: %2d: seek: offset=%" PRIdoff_t "buffer_offset=%zu"
4000cdb4: b4 16 a0 20 or %i2, 0x20, %i2
printf ("rtl: cache: %2d: read: past end by=%d\n", fd, (int) buffer_read);
4000cdb8: a2 14 60 b0 or %l1, 0xb0, %l1
if (fd == cache->fd)
4000cdbc: 80 a6 40 14 cmp %i1, %l4
4000cdc0: 12 80 00 10 bne 4000ce00 <rtems_rtl_obj_cache_read+0x9c>
4000cdc4: 86 84 c0 1b addcc %l3, %i3, %g3
if ((offset + buffer_read) > cache->file_size)
4000cdc8: 84 44 a0 00 addx %l2, 0, %g2
4000cdcc: 80 a0 a0 00 cmp %g2, 0
4000cdd0: 04 80 00 68 ble 4000cf70 <rtems_rtl_obj_cache_read+0x20c>
<== ALWAYS TAKEN
4000cdd4: c2 06 20 04 ld [ %i0 + 4 ], %g1
buffer_read = cache->file_size - offset;
4000cdd8: b6 20 40 13 sub %g1, %l3, %i3
<== NOT EXECUTED
if ((offset >= cache->offset) &&
4000cddc: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
4000cde0: 80 a0 80 12 cmp %g2, %l2
4000cde4: 34 80 00 08 bg,a 4000ce04 <rtems_rtl_obj_cache_read+0xa0>
<== NEVER TAKEN
4000cde8: a8 10 00 12 mov %l2, %l4
<== NOT EXECUTED
4000cdec: 32 80 00 75 bne,a 4000cfc0 <rtems_rtl_obj_cache_read+0x25c>
<== NEVER TAKEN
4000cdf0: e0 06 20 14 ld [ %i0 + 0x14 ], %l0
<== NOT EXECUTED
4000cdf4: 80 a0 c0 13 cmp %g3, %l3
4000cdf8: 28 80 00 72 bleu,a 4000cfc0 <rtems_rtl_obj_cache_read+0x25c>
4000cdfc: e0 06 20 14 ld [ %i0 + 0x14 ], %l0
4000ce00: a8 10 00 12 mov %l2, %l4
4000ce04: aa 10 00 13 mov %l3, %l5
size_t buffer_offset = 0;
4000ce08: a0 10 20 00 clr %l0
if (rtems_rtl_trace (RTEMS_RTL_TRACE_CACHE))
4000ce0c: 40 00 0d fe call 40010604 <rtems_rtl_trace>
4000ce10: 90 10 28 00 mov 0x800, %o0
4000ce14: 80 a2 20 00 cmp %o0, 0
4000ce18: 32 80 00 38 bne,a 4000cef8 <rtems_rtl_obj_cache_read+0x194>
4000ce1c: c4 06 20 04 ld [ %i0 + 4 ], %g2
if (lseek (fd, offset + buffer_offset, SEEK_SET) < 0)
4000ce20: 96 10 20 00 clr %o3
4000ce24: 92 10 00 14 mov %l4, %o1
4000ce28: 94 10 00 15 mov %l5, %o2
4000ce2c: 7f ff ea e5 call 400079c0 <lseek>
4000ce30: 90 10 00 19 mov %i1, %o0
4000ce34: 80 a2 20 00 cmp %o0, 0
4000ce38: 06 80 00 d2 bl 4000d180 <rtems_rtl_obj_cache_read+0x41c>
<== NEVER TAKEN
4000ce3c: 82 04 00 1b add %l0, %i3, %g1
while (buffer_read)
4000ce40: 80 a6 e0 00 cmp %i3, 0
4000ce44: 12 80 00 09 bne 4000ce68 <rtems_rtl_obj_cache_read+0x104>
<== ALWAYS TAKEN
4000ce48: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
buffer_read -= r;
buffer_offset += r;
}
}
cache->offset = offset;
4000ce4c: 10 80 00 25 b 4000cee0 <rtems_rtl_obj_cache_read+0x17c>
<== NOT EXECUTED
4000ce50: e4 3e 20 08 std %l2, [ %i0 + 8 ]
<== NOT EXECUTED
if ((r == 0) && buffer_read)
4000ce54: 02 80 00 16 be 4000ceac <rtems_rtl_obj_cache_read+0x148>
4000ce58: 01 00 00 00 nop
while (buffer_read)
4000ce5c: b6 a6 c0 08 subcc %i3, %o0, %i3
4000ce60: 02 80 00 1f be 4000cedc <rtems_rtl_obj_cache_read+0x178>
4000ce64: a0 04 00 08 add %l0, %o0, %l0
int r = read (fd, cache->buffer + buffer_offset, buffer_read);
4000ce68: d2 06 20 18 ld [ %i0 + 0x18 ], %o1
4000ce6c: 94 10 00 1b mov %i3, %o2
4000ce70: 92 02 40 10 add %o1, %l0, %o1
4000ce74: 7f ff ee 23 call 40008700 <read>
4000ce78: 90 10 00 19 mov %i1, %o0
if (r < 0)
4000ce7c: 80 a2 20 00 cmp %o0, 0
4000ce80: 16 bf ff f5 bge 4000ce54 <rtems_rtl_obj_cache_read+0xf0>
<== ALWAYS TAKEN
4000ce84: 01 00 00 00 nop
rtems_rtl_set_error (errno, "file read failed");
4000ce88: 40 00 36 bb call 4001a974 <__errno>
<== NOT EXECUTED
4000ce8c: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
4000ce90: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
4000ce94: 13 10 00 c4 sethi %hi(0x40031000), %o1
<== NOT EXECUTED
4000ce98: 7f ff fb d5 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000ce9c: 92 12 60 98 or %o1, 0x98, %o1 ! 40031098 <reloc_target_flags+0x330>
<== NOT EXECUTED
cache->file_size = sb.st_size;
}
}
return false;
}
4000cea0: b0 0e 20 01 and %i0, 1, %i0
4000cea4: 81 c7 e0 08 ret
4000cea8: 81 e8 00 00 restore
if (rtems_rtl_trace (RTEMS_RTL_TRACE_CACHE))
4000ceac: 40 00 0d d6 call 40010604 <rtems_rtl_trace>
4000ceb0: 90 10 28 00 mov 0x800, %o0
4000ceb4: 80 a2 20 00 cmp %o0, 0
4000ceb8: 22 80 00 07 be,a 4000ced4 <rtems_rtl_obj_cache_read+0x170>
<== ALWAYS TAKEN
4000cebc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
printf ("rtl: cache: %2d: read: past end by=%d\n", fd, (int) buffer_read);
4000cec0: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
4000cec4: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000cec8: 40 00 2e a0 call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000cecc: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
cache->level = cache->level - buffer_read;
4000ced0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
4000ced4: b6 20 40 1b sub %g1, %i3, %i3
4000ced8: f6 26 20 14 st %i3, [ %i0 + 0x14 ]
cache->offset = offset;
4000cedc: e4 3e 20 08 std %l2, [ %i0 + 8 ]
if (cache->fd != fd)
4000cee0: c2 06 00 00 ld [ %i0 ], %g1
4000cee4: 80 a0 40 19 cmp %g1, %i1
4000cee8: 12 80 00 c2 bne 4000d1f0 <rtems_rtl_obj_cache_read+0x48c>
4000ceec: a8 10 00 19 mov %i1, %l4
4000cef0: 10 bf ff b3 b 4000cdbc <rtems_rtl_obj_cache_read+0x58>
4000cef4: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
(cache->file_size - offset));
4000cef8: 86 10 00 02 mov %g2, %g3
4000cefc: 84 10 20 00 clr %g2
printf ("rtl: cache: %2d: seek: offset=%" PRIdoff_t "buffer_offset=%zu"
4000cf00: 9a a0 c0 13 subcc %g3, %l3, %o5
4000cf04: 98 60 80 12 subx %g2, %l2, %o4
4000cf08: d8 3f bf 98 std %o4, [ %fp + -104 ]
4000cf0c: 9a 84 c0 1b addcc %l3, %i3, %o5
4000cf10: c8 07 bf 98 ld [ %fp + -104 ], %g4
4000cf14: c6 07 bf 9c ld [ %fp + -100 ], %g3
4000cf18: 98 44 a0 00 addx %l2, 0, %o4
4000cf1c: d8 3f bf 98 std %o4, [ %fp + -104 ]
4000cf20: 94 10 00 14 mov %l4, %o2
4000cf24: c2 07 bf 9c ld [ %fp + -100 ], %g1
4000cf28: c4 07 bf 98 ld [ %fp + -104 ], %g2
4000cf2c: e4 3f bf 98 std %l2, [ %fp + -104 ]
4000cf30: 9a 10 00 1b mov %i3, %o5
4000cf34: c2 23 a0 68 st %g1, [ %sp + 0x68 ]
4000cf38: 98 10 00 10 mov %l0, %o4
4000cf3c: c2 07 bf 98 ld [ %fp + -104 ], %g1
4000cf40: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4000cf44: 96 10 00 15 mov %l5, %o3
4000cf48: c2 07 bf 9c ld [ %fp + -100 ], %g1
4000cf4c: c8 23 a0 6c st %g4, [ %sp + 0x6c ]
4000cf50: 92 10 00 19 mov %i1, %o1
4000cf54: c6 23 a0 70 st %g3, [ %sp + 0x70 ]
4000cf58: 90 10 00 1a mov %i2, %o0
4000cf5c: c4 23 a0 64 st %g2, [ %sp + 0x64 ]
4000cf60: 40 00 2e 7a call 40018948 <__wrap_printf>
4000cf64: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
if (lseek (fd, offset + buffer_offset, SEEK_SET) < 0)
4000cf68: 10 bf ff af b 4000ce24 <rtems_rtl_obj_cache_read+0xc0>
4000cf6c: 96 10 20 00 clr %o3
if ((offset + buffer_read) > cache->file_size)
4000cf70: 32 bf ff 9c bne,a 4000cde0 <rtems_rtl_obj_cache_read+0x7c>
<== NEVER TAKEN
4000cf74: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
<== NOT EXECUTED
4000cf78: 80 a0 c0 01 cmp %g3, %g1
4000cf7c: 28 bf ff 99 bleu,a 4000cde0 <rtems_rtl_obj_cache_read+0x7c>
4000cf80: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
buffer_read = cache->file_size - offset;
4000cf84: 10 bf ff 96 b 4000cddc <rtems_rtl_obj_cache_read+0x78>
4000cf88: b6 20 40 13 sub %g1, %l3, %i3
if (offset > cache->file_size)
4000cf8c: 14 80 00 74 bg 4000d15c <rtems_rtl_obj_cache_read+0x3f8>
<== NEVER TAKEN
4000cf90: d6 06 20 04 ld [ %i0 + 4 ], %o3
4000cf94: 02 80 00 70 be 4000d154 <rtems_rtl_obj_cache_read+0x3f0>
<== ALWAYS TAKEN
4000cf98: 80 a4 c0 0b cmp %l3, %o3
if ((offset + *length) > cache->file_size)
4000cf9c: 86 84 c0 01 addcc %l3, %g1, %g3
<== NOT EXECUTED
4000cfa0: 84 44 a0 00 addx %l2, 0, %g2
4000cfa4: 80 a0 a0 00 cmp %g2, 0
4000cfa8: 34 80 00 82 bg,a 4000d1b0 <rtems_rtl_obj_cache_read+0x44c>
<== NEVER TAKEN
4000cfac: 96 22 c0 13 sub %o3, %l3, %o3
<== NOT EXECUTED
4000cfb0: 02 80 00 7d be 4000d1a4 <rtems_rtl_obj_cache_read+0x440>
<== ALWAYS TAKEN
4000cfb4: 80 a0 c0 0b cmp %g3, %o3
4000cfb8: 10 bf ff 7b b 4000cda4 <rtems_rtl_obj_cache_read+0x40>
<== NOT EXECUTED
4000cfbc: a8 10 00 19 mov %i1, %l4
<== NOT EXECUTED
(offset < (cache->offset + cache->level)))
4000cfc0: 9a 80 c0 10 addcc %g3, %l0, %o5
4000cfc4: 98 40 a0 00 addx %g2, 0, %o4
if ((offset >= cache->offset) &&
4000cfc8: 80 a3 00 12 cmp %o4, %l2
4000cfcc: 34 80 00 08 bg,a 4000cfec <rtems_rtl_obj_cache_read+0x288>
<== NEVER TAKEN
4000cfd0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
<== NOT EXECUTED
4000cfd4: 32 bf ff 8c bne,a 4000ce04 <rtems_rtl_obj_cache_read+0xa0>
<== NEVER TAKEN
4000cfd8: a8 10 00 12 mov %l2, %l4
<== NOT EXECUTED
4000cfdc: 80 a3 40 13 cmp %o5, %l3
4000cfe0: 28 bf ff 89 bleu,a 4000ce04 <rtems_rtl_obj_cache_read+0xa0>
4000cfe4: a8 10 00 12 mov %l2, %l4
*buffer = cache->buffer + buffer_offset;
4000cfe8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
buffer_offset = offset - cache->offset;
4000cfec: b6 24 c0 03 sub %l3, %g3, %i3
*buffer = cache->buffer + buffer_offset;
4000cff0: 82 00 40 1b add %g1, %i3, %g1
4000cff4: c2 27 00 00 st %g1, [ %i4 ]
size = cache->level - buffer_offset;
4000cff8: a0 24 00 1b sub %l0, %i3, %l0
if (*length <= size)
4000cffc: c2 07 40 00 ld [ %i5 ], %g1
4000d000: 80 a0 40 10 cmp %g1, %l0
4000d004: 28 bf ff a7 bleu,a 4000cea0 <rtems_rtl_obj_cache_read+0x13c>
4000d008: b0 10 20 01 mov 1, %i0
if (rtems_rtl_trace (RTEMS_RTL_TRACE_CACHE))
4000d00c: 40 00 0d 7e call 40010604 <rtems_rtl_trace>
4000d010: 90 10 28 00 mov 0x800, %o0
4000d014: 80 a2 20 00 cmp %o0, 0
4000d018: 32 80 00 48 bne,a 4000d138 <rtems_rtl_obj_cache_read+0x3d4>
<== NEVER TAKEN
4000d01c: d8 06 20 14 ld [ %i0 + 0x14 ], %o4
<== NOT EXECUTED
memmove (cache->buffer, cache->buffer + buffer_offset, size);
4000d020: d0 06 20 18 ld [ %i0 + 0x18 ], %o0
4000d024: 92 02 00 1b add %o0, %i3, %o1
4000d028: 40 00 37 8b call 4001ae54 <memmove>
4000d02c: 94 10 00 10 mov %l0, %o2
buffer_read = cache->size - cache->level;
4000d030: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
cache->offset = offset;
4000d034: e4 3e 20 08 std %l2, [ %i0 + 8 ]
if ((offset + buffer_offset + buffer_read) > cache->file_size)
4000d038: aa 84 c0 10 addcc %l3, %l0, %l5
cache->level = size;
4000d03c: e0 26 20 14 st %l0, [ %i0 + 0x14 ]
if ((offset + buffer_offset + buffer_read) > cache->file_size)
4000d040: a8 44 a0 00 addx %l2, 0, %l4
buffer_read = cache->size - cache->level;
4000d044: b6 26 c0 10 sub %i3, %l0, %i3
if ((offset + buffer_offset + buffer_read) > cache->file_size)
4000d048: 86 85 40 1b addcc %l5, %i3, %g3
4000d04c: 84 45 20 00 addx %l4, 0, %g2
4000d050: 80 a0 a0 00 cmp %g2, 0
4000d054: 14 80 00 06 bg 4000d06c <rtems_rtl_obj_cache_read+0x308>
<== NEVER TAKEN
4000d058: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000d05c: 12 bf ff 6c bne 4000ce0c <rtems_rtl_obj_cache_read+0xa8>
<== NEVER TAKEN
4000d060: 80 a0 c0 01 cmp %g3, %g1
4000d064: 08 bf ff 6a bleu 4000ce0c <rtems_rtl_obj_cache_read+0xa8>
4000d068: 01 00 00 00 nop
buffer_read = cache->file_size - (offset + buffer_offset);
4000d06c: 82 20 40 13 sub %g1, %l3, %g1
4000d070: 10 bf ff 67 b 4000ce0c <rtems_rtl_obj_cache_read+0xa8>
4000d074: b6 20 40 10 sub %g1, %l0, %i3
printf ("rtl: cache: %2d: fd=%d offset=%" PRIdoff_t "length=%zu area=[%"
4000d078: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
cache->offset, cache->offset + cache->level,
4000d07c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
printf ("rtl: cache: %2d: fd=%d offset=%" PRIdoff_t "length=%zu area=[%"
4000d080: b6 80 c0 01 addcc %g3, %g1, %i3
4000d084: b4 40 a0 00 addx %g2, 0, %i2
4000d088: f4 3f bf 98 std %i2, [ %fp + -104 ]
4000d08c: 96 10 00 12 mov %l2, %o3
4000d090: f4 1f bf 98 ldd [ %fp + -104 ], %i2
4000d094: c4 3f bf 98 std %g2, [ %fp + -104 ]
4000d098: 98 10 00 13 mov %l3, %o4
4000d09c: da 07 40 00 ld [ %i5 ], %o5
4000d0a0: 92 84 c0 0d addcc %l3, %o5, %o1
4000d0a4: c8 07 bf 98 ld [ %fp + -104 ], %g4
4000d0a8: c6 07 bf 9c ld [ %fp + -100 ], %g3
4000d0ac: 90 44 a0 00 addx %l2, 0, %o0
4000d0b0: d0 3f bf 98 std %o0, [ %fp + -104 ]
4000d0b4: 92 10 00 19 mov %i1, %o1
4000d0b8: c2 07 bf 9c ld [ %fp + -100 ], %g1
4000d0bc: c4 07 bf 98 ld [ %fp + -104 ], %g2
4000d0c0: e4 3f bf 98 std %l2, [ %fp + -104 ]
4000d0c4: 11 10 00 c3 sethi %hi(0x40030c00), %o0
4000d0c8: de 06 20 04 ld [ %i0 + 4 ], %o7
4000d0cc: c2 23 a0 68 st %g1, [ %sp + 0x68 ]
4000d0d0: 90 12 23 00 or %o0, 0x300, %o0
4000d0d4: c2 07 bf 98 ld [ %fp + -104 ], %g1
4000d0d8: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4000d0dc: c2 07 bf 9c ld [ %fp + -100 ], %g1
4000d0e0: f6 23 a0 78 st %i3, [ %sp + 0x78 ]
4000d0e4: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
4000d0e8: de 23 a0 7c st %o7, [ %sp + 0x7c ]
4000d0ec: f4 23 a0 74 st %i2, [ %sp + 0x74 ]
4000d0f0: c8 23 a0 6c st %g4, [ %sp + 0x6c ]
4000d0f4: c6 23 a0 70 st %g3, [ %sp + 0x70 ]
4000d0f8: c4 23 a0 64 st %g2, [ %sp + 0x64 ]
4000d0fc: 40 00 2e 13 call 40018948 <__wrap_printf>
4000d100: d4 06 00 00 ld [ %i0 ], %o2
if (*length > cache->size)
4000d104: c2 07 40 00 ld [ %i5 ], %g1
4000d108: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
4000d10c: 80 a0 40 1b cmp %g1, %i3
4000d110: 28 bf ff 22 bleu,a 4000cd98 <rtems_rtl_obj_cache_read+0x34>
<== ALWAYS TAKEN
4000d114: e8 06 00 00 ld [ %i0 ], %l4
rtems_rtl_set_error (EINVAL, "read size larger than cache size");
4000d118: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
4000d11c: 13 10 00 c3 sethi %hi(0x40030c00), %o1
<== NOT EXECUTED
return false;
4000d120: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "read size larger than cache size");
4000d124: 92 12 63 60 or %o1, 0x360, %o1
<== NOT EXECUTED
4000d128: 7f ff fb 31 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000d12c: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
}
4000d130: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d134: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtl: cache: %2d: copy-down: buffer_offset=%d size=%d level=%d\n",
4000d138: 96 10 00 10 mov %l0, %o3
<== NOT EXECUTED
4000d13c: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
4000d140: 92 10 00 14 mov %l4, %o1
<== NOT EXECUTED
4000d144: 40 00 2e 01 call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000d148: 90 10 00 16 mov %l6, %o0
<== NOT EXECUTED
memmove (cache->buffer, cache->buffer + buffer_offset, size);
4000d14c: 10 bf ff b6 b 4000d024 <rtems_rtl_obj_cache_read+0x2c0>
<== NOT EXECUTED
4000d150: d0 06 20 18 ld [ %i0 + 0x18 ], %o0
<== NOT EXECUTED
if (offset > cache->file_size)
4000d154: 08 bf ff 93 bleu 4000cfa0 <rtems_rtl_obj_cache_read+0x23c>
<== ALWAYS TAKEN
4000d158: 86 84 c0 01 addcc %l3, %g1, %g3
rtems_rtl_set_error (EINVAL, "offset past end of file: offset=%i size=%i",
4000d15c: 94 10 00 13 mov %l3, %o2
<== NOT EXECUTED
4000d160: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
4000d164: 13 10 00 c3 sethi %hi(0x40030c00), %o1
<== NOT EXECUTED
return false;
4000d168: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "offset past end of file: offset=%i size=%i",
4000d16c: 7f ff fb 20 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000d170: 92 12 63 88 or %o1, 0x388, %o1
<== NOT EXECUTED
4000d174: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
4000d178: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d17c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rtl_set_error (errno, "file seek failed");
4000d180: 40 00 35 fd call 4001a974 <__errno>
<== NOT EXECUTED
4000d184: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000d188: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
4000d18c: 13 10 00 c4 sethi %hi(0x40031000), %o1
<== NOT EXECUTED
4000d190: 7f ff fb 17 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000d194: 92 12 60 80 or %o1, 0x80, %o1 ! 40031080 <reloc_target_flags+0x318>
<== NOT EXECUTED
4000d198: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
4000d19c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d1a0: 81 e8 00 00 restore
<== NOT EXECUTED
if ((offset + *length) > cache->file_size)
4000d1a4: 08 bf ff 00 bleu 4000cda4 <rtems_rtl_obj_cache_read+0x40>
4000d1a8: a8 10 00 19 mov %i1, %l4
*length = cache->file_size - offset;
4000d1ac: 96 22 c0 13 sub %o3, %l3, %o3
4000d1b0: d6 27 40 00 st %o3, [ %i5 ]
if (rtems_rtl_trace (RTEMS_RTL_TRACE_CACHE))
4000d1b4: 40 00 0d 14 call 40010604 <rtems_rtl_trace>
4000d1b8: 90 10 28 00 mov 0x800, %o0
4000d1bc: 80 a2 20 00 cmp %o0, 0
4000d1c0: 32 80 00 05 bne,a 4000d1d4 <rtems_rtl_obj_cache_read+0x470>
<== ALWAYS TAKEN
4000d1c4: d4 07 40 00 ld [ %i5 ], %o2
4000d1c8: e8 06 00 00 ld [ %i0 ], %l4
<== NOT EXECUTED
4000d1cc: 10 bf fe f6 b 4000cda4 <rtems_rtl_obj_cache_read+0x40>
<== NOT EXECUTED
4000d1d0: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
<== NOT EXECUTED
printf ("rtl: cache: %2d: truncate length=%d\n", fd, (int) *length);
4000d1d4: 92 10 00 19 mov %i1, %o1
4000d1d8: 11 10 00 c3 sethi %hi(0x40030c00), %o0
4000d1dc: 40 00 2d db call 40018948 <__wrap_printf>
4000d1e0: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 40030fb8 <reloc_target_flags+0x250>
4000d1e4: e8 06 00 00 ld [ %i0 ], %l4
4000d1e8: 10 bf fe ef b 4000cda4 <rtems_rtl_obj_cache_read+0x40>
4000d1ec: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
cache->fd = fd;
4000d1f0: f2 26 00 00 st %i1, [ %i0 ]
if (fstat (cache->fd, &sb) < 0)
4000d1f4: 92 07 bf a0 add %fp, -96, %o1
4000d1f8: 7f ff e8 d1 call 4000753c <fstat>
4000d1fc: 90 10 00 19 mov %i1, %o0
4000d200: 80 a2 20 00 cmp %o0, 0
4000d204: 06 80 00 06 bl 4000d21c <rtems_rtl_obj_cache_read+0x4b8>
<== NEVER TAKEN
4000d208: c2 07 bf c4 ld [ %fp + -60 ], %g1
cache->file_size = sb.st_size;
4000d20c: c2 26 20 04 st %g1, [ %i0 + 4 ]
4000d210: e8 06 00 00 ld [ %i0 ], %l4
4000d214: 10 bf fe ea b 4000cdbc <rtems_rtl_obj_cache_read+0x58>
4000d218: f6 06 20 10 ld [ %i0 + 0x10 ], %i3
rtems_rtl_set_error (errno, "file stat failed");
4000d21c: 40 00 35 d6 call 4001a974 <__errno>
<== NOT EXECUTED
4000d220: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000d224: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
4000d228: 13 10 00 c4 sethi %hi(0x40031000), %o1
<== NOT EXECUTED
4000d22c: 7f ff fa f0 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000d230: 92 12 60 d8 or %o1, 0xd8, %o1 ! 400310d8 <reloc_target_flags+0x370>
<== NOT EXECUTED
4000d234: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
4000d238: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d23c: 81 e8 00 00 restore
<== NOT EXECUTED
4000d240 <rtems_rtl_obj_cache_read_byval>:
rtems_rtl_obj_cache_read_byval (rtems_rtl_obj_cache* cache,
int fd,
off_t offset,
void* buffer,
size_t length)
{
4000d240: 9d e3 bf 98 save %sp, -104, %sp
void* cbuffer = 0;
size_t len = length;
bool ok = rtems_rtl_obj_cache_read (cache, fd, offset, &cbuffer, &len);
4000d244: 90 10 00 18 mov %i0, %o0
void* cbuffer = 0;
4000d248: c0 27 bf f8 clr [ %fp + -8 ]
bool ok = rtems_rtl_obj_cache_read (cache, fd, offset, &cbuffer, &len);
4000d24c: 9a 07 bf fc add %fp, -4, %o5
size_t len = length;
4000d250: fa 27 bf fc st %i5, [ %fp + -4 ]
bool ok = rtems_rtl_obj_cache_read (cache, fd, offset, &cbuffer, &len);
4000d254: 98 07 bf f8 add %fp, -8, %o4
4000d258: 94 10 00 1a mov %i2, %o2
4000d25c: 96 10 00 1b mov %i3, %o3
4000d260: 7f ff fe c1 call 4000cd64 <rtems_rtl_obj_cache_read>
4000d264: 92 10 00 19 mov %i1, %o1
if (ok && (len != length))
4000d268: 80 a2 20 00 cmp %o0, 0
4000d26c: 02 80 00 07 be 4000d288 <rtems_rtl_obj_cache_read_byval+0x48>
<== NEVER TAKEN
4000d270: b0 10 00 08 mov %o0, %i0
4000d274: d4 07 bf fc ld [ %fp + -4 ], %o2
4000d278: 80 a2 80 1d cmp %o2, %i5
4000d27c: 22 80 00 06 be,a 4000d294 <rtems_rtl_obj_cache_read_byval+0x54>
<== ALWAYS TAKEN
4000d280: d2 07 bf f8 ld [ %fp + -8 ], %o1
4000d284: b0 10 20 00 clr %i0
<== NOT EXECUTED
ok = false;
if (ok)
memcpy (buffer, cbuffer, length);
return ok;
}
4000d288: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
4000d28c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d290: 81 e8 00 00 restore
<== NOT EXECUTED
memcpy (buffer, cbuffer, length);
4000d294: 90 10 00 1c mov %i4, %o0
4000d298: 40 00 36 b3 call 4001ad64 <memcpy>
4000d29c: b0 0e 20 ff and %i0, 0xff, %i0
}
4000d2a0: 81 c7 e0 08 ret
4000d2a4: 81 e8 00 00 restore
4000c354 <rtems_rtl_obj_caches>:
void
rtems_rtl_obj_caches (rtems_rtl_obj_cache** symbols,
rtems_rtl_obj_cache** strings,
rtems_rtl_obj_cache** relocs)
{
if (!rtl)
4000c354: 03 10 00 d8 sethi %hi(0x40036000), %g1
4000c358: c2 00 61 e4 ld [ %g1 + 0x1e4 ], %g1 ! 400361e4 <rtl>
4000c35c: 80 a0 60 00 cmp %g1, 0
4000c360: 02 80 00 0f be 4000c39c <rtems_rtl_obj_caches+0x48>
<== NEVER TAKEN
4000c364: 80 a2 20 00 cmp %o0, 0
if (relocs)
*relocs = NULL;
}
else
{
if (symbols)
4000c368: 02 80 00 03 be 4000c374 <rtems_rtl_obj_caches+0x20>
<== NEVER TAKEN
4000c36c: 84 00 60 98 add %g1, 0x98, %g2
*symbols = &rtl->symbols;
4000c370: c4 22 00 00 st %g2, [ %o0 ]
if (strings)
4000c374: 80 a2 60 00 cmp %o1, 0
4000c378: 02 80 00 03 be 4000c384 <rtems_rtl_obj_caches+0x30>
4000c37c: 84 00 60 b8 add %g1, 0xb8, %g2
*strings = &rtl->strings;
4000c380: c4 22 40 00 st %g2, [ %o1 ]
if (relocs)
4000c384: 80 a2 a0 00 cmp %o2, 0
4000c388: 02 80 00 03 be 4000c394 <rtems_rtl_obj_caches+0x40>
4000c38c: 82 00 60 d8 add %g1, 0xd8, %g1
*relocs = &rtl->relocs;
4000c390: c2 22 80 00 st %g1, [ %o2 ]
}
}
4000c394: 81 c3 e0 08 retl
4000c398: 01 00 00 00 nop
if (symbols)
4000c39c: 32 80 00 02 bne,a 4000c3a4 <rtems_rtl_obj_caches+0x50>
<== NOT EXECUTED
4000c3a0: c0 22 00 00 clr [ %o0 ]
<== NOT EXECUTED
if (strings)
4000c3a4: 80 a2 60 00 cmp %o1, 0
<== NOT EXECUTED
4000c3a8: 32 80 00 02 bne,a 4000c3b0 <rtems_rtl_obj_caches+0x5c>
<== NOT EXECUTED
4000c3ac: c0 22 40 00 clr [ %o1 ]
<== NOT EXECUTED
if (relocs)
4000c3b0: 80 a2 a0 00 cmp %o2, 0
<== NOT EXECUTED
4000c3b4: 02 bf ff f8 be 4000c394 <rtems_rtl_obj_caches+0x40>
<== NOT EXECUTED
4000c3b8: 01 00 00 00 nop
<== NOT EXECUTED
*relocs = NULL;
4000c3bc: 81 c3 e0 08 retl
<== NOT EXECUTED
4000c3c0: c0 22 80 00 clr [ %o2 ]
<== NOT EXECUTED
4000c3c4 <rtems_rtl_obj_caches_flush>:
void
rtems_rtl_obj_caches_flush (void)
{
4000c3c4: 9d e3 bf a0 save %sp, -96, %sp
if (rtl)
4000c3c8: 3b 10 00 d8 sethi %hi(0x40036000), %i5
4000c3cc: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0 ! 400361e4 <rtl>
4000c3d0: 80 a2 20 00 cmp %o0, 0
4000c3d4: 02 80 00 0a be 4000c3fc <rtems_rtl_obj_caches_flush+0x38>
<== NEVER TAKEN
4000c3d8: 01 00 00 00 nop
{
rtems_rtl_obj_cache_flush (&rtl->symbols);
4000c3dc: 40 00 02 50 call 4000cd1c <rtems_rtl_obj_cache_flush>
4000c3e0: 90 02 20 98 add %o0, 0x98, %o0
rtems_rtl_obj_cache_flush (&rtl->strings);
4000c3e4: d0 07 61 e4 ld [ %i5 + 0x1e4 ], %o0
4000c3e8: 40 00 02 4d call 4000cd1c <rtems_rtl_obj_cache_flush>
4000c3ec: 90 02 20 b8 add %o0, 0xb8, %o0
rtems_rtl_obj_cache_flush (&rtl->relocs);
4000c3f0: f0 07 61 e4 ld [ %i5 + 0x1e4 ], %i0
4000c3f4: 40 00 02 4a call 4000cd1c <rtems_rtl_obj_cache_flush>
4000c3f8: 91 ee 20 d8 restore %i0, 0xd8, %o0
}
}
4000c3fc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c400: 81 e8 00 00 restore
<== NOT EXECUTED
4000d320 <rtems_rtl_obj_comp_close>:
void
rtems_rtl_obj_comp_close (rtems_rtl_obj_comp* comp)
{
4000d320: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_OBJECT, comp->buffer);
4000d324: d2 06 20 20 ld [ %i0 + 0x20 ], %o1
<== NOT EXECUTED
4000d328: 7f ff f4 68 call 4000a4c8 <rtems_rtl_alloc_del>
<== NOT EXECUTED
4000d32c: 90 10 20 00 clr %o0
<== NOT EXECUTED
comp->cache = NULL;
comp->fd = -1;
4000d330: 82 10 3f ff mov -1, %g1
<== NOT EXECUTED
comp->cache = NULL;
4000d334: c0 26 00 00 clr [ %i0 ]
<== NOT EXECUTED
comp->fd = -1;
4000d338: c2 26 20 04 st %g1, [ %i0 + 4 ]
<== NOT EXECUTED
comp->compression = RTEMS_RTL_COMP_LZ77;
4000d33c: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
comp->level = 0;
comp->size = 0;
comp->offset = 0;
4000d340: c0 26 20 10 clr [ %i0 + 0x10 ]
<== NOT EXECUTED
4000d344: c0 26 20 14 clr [ %i0 + 0x14 ]
<== NOT EXECUTED
comp->compression = RTEMS_RTL_COMP_LZ77;
4000d348: c2 26 20 08 st %g1, [ %i0 + 8 ]
<== NOT EXECUTED
comp->level = 0;
4000d34c: c0 26 20 1c clr [ %i0 + 0x1c ]
<== NOT EXECUTED
comp->size = 0;
4000d350: c0 26 20 18 clr [ %i0 + 0x18 ]
<== NOT EXECUTED
comp->read = 0;
4000d354: c0 26 20 24 clr [ %i0 + 0x24 ]
<== NOT EXECUTED
}
4000d358: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d35c: 81 e8 00 00 restore
<== NOT EXECUTED
4000d2a8 <rtems_rtl_obj_comp_open>:
#include <stdio.h>
bool
rtems_rtl_obj_comp_open (rtems_rtl_obj_comp* comp,
size_t size)
{
4000d2a8: 9d e3 bf a0 save %sp, -96, %sp
comp->cache = NULL;
comp->fd = -1;
4000d2ac: 82 10 3f ff mov -1, %g1
comp->cache = NULL;
4000d2b0: c0 26 00 00 clr [ %i0 ]
comp->compression = RTEMS_RTL_COMP_LZ77;
comp->offset = 0;
comp->size = size;
comp->level = 0;
comp->buffer = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_OBJECT, size, false);
4000d2b4: 94 10 20 00 clr %o2
comp->fd = -1;
4000d2b8: c2 26 20 04 st %g1, [ %i0 + 4 ]
comp->compression = RTEMS_RTL_COMP_LZ77;
4000d2bc: 82 10 20 01 mov 1, %g1
comp->offset = 0;
4000d2c0: c0 26 20 10 clr [ %i0 + 0x10 ]
comp->buffer = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_OBJECT, size, false);
4000d2c4: 92 10 00 19 mov %i1, %o1
comp->offset = 0;
4000d2c8: c0 26 20 14 clr [ %i0 + 0x14 ]
comp->buffer = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_OBJECT, size, false);
4000d2cc: 90 10 20 00 clr %o0
comp->compression = RTEMS_RTL_COMP_LZ77;
4000d2d0: c2 26 20 08 st %g1, [ %i0 + 8 ]
comp->size = size;
4000d2d4: f2 26 20 18 st %i1, [ %i0 + 0x18 ]
comp->buffer = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_OBJECT, size, false);
4000d2d8: 7f ff f4 53 call 4000a424 <rtems_rtl_alloc_new>
4000d2dc: c0 26 20 1c clr [ %i0 + 0x1c ]
if (!comp->buffer)
4000d2e0: 80 a2 20 00 cmp %o0, 0
4000d2e4: 02 80 00 07 be 4000d300 <rtems_rtl_obj_comp_open+0x58>
<== NEVER TAKEN
4000d2e8: d0 26 20 20 st %o0, [ %i0 + 0x20 ]
{
rtems_rtl_set_error (ENOMEM, "no memory for compressor buffer");
return false;
}
comp->read = 0;
4000d2ec: c0 26 20 24 clr [ %i0 + 0x24 ]
return true;
4000d2f0: b0 10 20 01 mov 1, %i0
}
4000d2f4: b0 0e 20 01 and %i0, 1, %i0
4000d2f8: 81 c7 e0 08 ret
4000d2fc: 81 e8 00 00 restore
rtems_rtl_set_error (ENOMEM, "no memory for compressor buffer");
4000d300: 90 10 20 0c mov 0xc, %o0
<== NOT EXECUTED
4000d304: 13 10 00 c4 sethi %hi(0x40031000), %o1
<== NOT EXECUTED
return false;
4000d308: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (ENOMEM, "no memory for compressor buffer");
4000d30c: 92 12 60 f0 or %o1, 0xf0, %o1
<== NOT EXECUTED
4000d310: 7f ff fa b7 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000d314: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
}
4000d318: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d31c: 81 e8 00 00 restore
<== NOT EXECUTED
4000d37c <rtems_rtl_obj_comp_read>:
bool
rtems_rtl_obj_comp_read (rtems_rtl_obj_comp* comp,
void* buffer,
size_t length)
{
4000d37c: 9d e3 bf 98 save %sp, -104, %sp
uint8_t* bin = buffer;
if (!comp->cache)
4000d380: c2 06 00 00 ld [ %i0 ], %g1
4000d384: 80 a0 60 00 cmp %g1, 0
4000d388: 02 80 00 70 be 4000d548 <rtems_rtl_obj_comp_read+0x1cc>
<== NEVER TAKEN
4000d38c: 90 10 20 16 mov 0x16, %o0
{
rtems_rtl_set_error (EINVAL, "not open");
return false;
}
if (comp->fd != comp->cache->fd)
4000d390: c4 06 20 04 ld [ %i0 + 4 ], %g2
4000d394: c2 00 40 00 ld [ %g1 ], %g1
4000d398: 80 a0 80 01 cmp %g2, %g1
4000d39c: 32 80 00 02 bne,a 4000d3a4 <rtems_rtl_obj_comp_read+0x28>
<== NEVER TAKEN
4000d3a0: c0 26 20 1c clr [ %i0 + 0x1c ]
<== NOT EXECUTED
{
comp->level = 0;
}
while (length)
4000d3a4: 80 a6 a0 00 cmp %i2, 0
4000d3a8: 22 80 00 58 be,a 4000d508 <rtems_rtl_obj_comp_read+0x18c>
<== NEVER TAKEN
4000d3ac: b0 10 20 01 mov 1, %i0
<== NOT EXECUTED
4000d3b0: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
{
size_t buffer_level;
buffer_level = length > comp->level ? comp->level : length;
4000d3b4: 80 a7 40 1a cmp %i5, %i2
4000d3b8: 08 80 00 03 bleu 4000d3c4 <rtems_rtl_obj_comp_read+0x48>
4000d3bc: b6 10 20 02 mov 2, %i3
4000d3c0: ba 10 00 1a mov %i2, %i5
if (buffer_level)
4000d3c4: 80 a7 60 00 cmp %i5, 0
4000d3c8: 32 80 00 3c bne,a 4000d4b8 <rtems_rtl_obj_comp_read+0x13c>
4000d3cc: d2 06 20 20 ld [ %i0 + 0x20 ], %o1
uint8_t* input = NULL;
uint16_t block_size;
size_t in_length = sizeof (block_size);
int decompressed;
if (!rtems_rtl_obj_cache_read (comp->cache, comp->fd, comp->offset,
4000d3d0: d0 1e 00 00 ldd [ %i0 ], %o0
4000d3d4: d4 1e 20 10 ldd [ %i0 + 0x10 ], %o2
uint8_t* input = NULL;
4000d3d8: c0 27 bf f8 clr [ %fp + -8 ]
if (!rtems_rtl_obj_cache_read (comp->cache, comp->fd, comp->offset,
4000d3dc: 9a 07 bf fc add %fp, -4, %o5
size_t in_length = sizeof (block_size);
4000d3e0: f6 27 bf fc st %i3, [ %fp + -4 ]
if (!rtems_rtl_obj_cache_read (comp->cache, comp->fd, comp->offset,
4000d3e4: 7f ff fe 60 call 4000cd64 <rtems_rtl_obj_cache_read>
4000d3e8: 98 07 bf f8 add %fp, -8, %o4
4000d3ec: 80 a2 20 00 cmp %o0, 0
4000d3f0: 02 80 00 4c be 4000d520 <rtems_rtl_obj_comp_read+0x1a4>
<== NEVER TAKEN
4000d3f4: c2 07 bf f8 ld [ %fp + -8 ], %g1
(void**) &input, &in_length))
return false;
block_size = (input[0] << 8) | input[1];
comp->offset += sizeof (block_size);
4000d3f8: c4 1e 20 10 ldd [ %i0 + 0x10 ], %g2
block_size = (input[0] << 8) | input[1];
4000d3fc: f8 08 40 00 ldub [ %g1 ], %i4
comp->offset += sizeof (block_size);
4000d400: 96 80 e0 02 addcc %g3, 2, %o3
block_size = (input[0] << 8) | input[1];
4000d404: c2 08 60 01 ldub [ %g1 + 1 ], %g1
comp->offset += sizeof (block_size);
4000d408: 94 40 a0 00 addx %g2, 0, %o2
4000d40c: d4 3e 20 10 std %o2, [ %i0 + 0x10 ]
block_size = (input[0] << 8) | input[1];
4000d410: b9 2f 20 08 sll %i4, 8, %i4
in_length = block_size;
if (!rtems_rtl_obj_cache_read (comp->cache, comp->fd, comp->offset,
4000d414: d0 1e 00 00 ldd [ %i0 ], %o0
block_size = (input[0] << 8) | input[1];
4000d418: b8 17 00 01 or %i4, %g1, %i4
if (!rtems_rtl_obj_cache_read (comp->cache, comp->fd, comp->offset,
4000d41c: 9a 07 bf fc add %fp, -4, %o5
in_length = block_size;
4000d420: b9 2f 20 10 sll %i4, 0x10, %i4
if (!rtems_rtl_obj_cache_read (comp->cache, comp->fd, comp->offset,
4000d424: 98 07 bf f8 add %fp, -8, %o4
in_length = block_size;
4000d428: bb 37 20 10 srl %i4, 0x10, %i5
if (!rtems_rtl_obj_cache_read (comp->cache, comp->fd, comp->offset,
4000d42c: 7f ff fe 4e call 4000cd64 <rtems_rtl_obj_cache_read>
4000d430: fa 27 bf fc st %i5, [ %fp + -4 ]
4000d434: 80 a2 20 00 cmp %o0, 0
4000d438: 02 80 00 3a be 4000d520 <rtems_rtl_obj_comp_read+0x1a4>
<== NEVER TAKEN
4000d43c: d6 07 bf fc ld [ %fp + -4 ], %o3
(void**) &input, &in_length))
return false;
if (in_length != block_size)
4000d440: 80 a7 40 0b cmp %i5, %o3
4000d444: 12 80 00 48 bne 4000d564 <rtems_rtl_obj_comp_read+0x1e8>
<== NEVER TAKEN
4000d448: 94 10 00 1d mov %i5, %o2
rtems_rtl_set_error (EIO, "compressed read failed: bs=%u in=%zu",
block_size, in_length);
return false;
}
switch (comp->compression)
4000d44c: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000d450: 80 a0 60 00 cmp %g1, 0
4000d454: 02 80 00 37 be 4000d530 <rtems_rtl_obj_comp_read+0x1b4>
<== NEVER TAKEN
4000d458: 80 a0 60 01 cmp %g1, 1
4000d45c: 12 80 00 2e bne 4000d514 <rtems_rtl_obj_comp_read+0x198>
<== NEVER TAKEN
4000d460: 13 10 00 c4 sethi %hi(0x40031000), %o1
memcpy (comp->buffer, input, in_length);
decompressed = in_length;
break;
case RTEMS_RTL_COMP_LZ77:
decompressed = fastlz_decompress (input, in_length,
4000d464: d6 06 20 18 ld [ %i0 + 0x18 ], %o3
4000d468: d4 06 20 20 ld [ %i0 + 0x20 ], %o2
4000d46c: d0 07 bf f8 ld [ %fp + -8 ], %o0
4000d470: 7f ff f2 e3 call 40009ffc <fastlz_decompress>
4000d474: 92 10 00 1d mov %i5, %o1
comp->buffer, comp->size);
if (decompressed == 0)
4000d478: 80 a2 20 00 cmp %o0, 0
4000d47c: 22 80 00 42 be,a 4000d584 <rtems_rtl_obj_comp_read+0x208>
<== NEVER TAKEN
4000d480: 90 10 20 09 mov 9, %o0
<== NOT EXECUTED
default:
rtems_rtl_set_error (EINVAL, "bad compression type");
return false;
}
comp->offset += block_size;
4000d484: c4 1e 20 10 ldd [ %i0 + 0x10 ], %g2
4000d488: b9 37 20 10 srl %i4, 0x10, %i4
comp->level = decompressed;
4000d48c: d0 26 20 1c st %o0, [ %i0 + 0x1c ]
comp->offset += block_size;
4000d490: 9a 80 c0 1c addcc %g3, %i4, %o5
4000d494: 98 40 a0 00 addx %g2, 0, %o4
comp->level = decompressed;
4000d498: ba 10 00 08 mov %o0, %i5
buffer_level = length > comp->level ? comp->level : length;
4000d49c: 80 a7 40 1a cmp %i5, %i2
4000d4a0: 18 bf ff c8 bgu 4000d3c0 <rtems_rtl_obj_comp_read+0x44>
4000d4a4: d8 3e 20 10 std %o4, [ %i0 + 0x10 ]
if (buffer_level)
4000d4a8: 80 a7 60 00 cmp %i5, 0
4000d4ac: 22 bf ff ca be,a 4000d3d4 <rtems_rtl_obj_comp_read+0x58>
<== NEVER TAKEN
4000d4b0: d0 1e 00 00 ldd [ %i0 ], %o0
<== NOT EXECUTED
memcpy (bin, comp->buffer, buffer_level);
4000d4b4: d2 06 20 20 ld [ %i0 + 0x20 ], %o1
4000d4b8: 94 10 00 1d mov %i5, %o2
4000d4bc: 40 00 36 2a call 4001ad64 <memcpy>
4000d4c0: 90 10 00 19 mov %i1, %o0
if ((comp->level - buffer_level) != 0)
4000d4c4: d4 06 20 1c ld [ %i0 + 0x1c ], %o2
4000d4c8: 80 a2 80 1d cmp %o2, %i5
4000d4cc: 02 80 00 07 be 4000d4e8 <rtems_rtl_obj_comp_read+0x16c>
4000d4d0: 82 10 00 1d mov %i5, %g1
memmove (comp->buffer,
4000d4d4: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000d4d8: 94 22 80 1d sub %o2, %i5, %o2
4000d4dc: 40 00 36 5e call 4001ae54 <memmove>
4000d4e0: 92 02 00 1d add %o0, %i5, %o1
4000d4e4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
comp->read += buffer_level;
4000d4e8: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
comp->level -= buffer_level;
4000d4ec: 82 20 40 1d sub %g1, %i5, %g1
comp->read += buffer_level;
4000d4f0: 84 00 80 1d add %g2, %i5, %g2
comp->level -= buffer_level;
4000d4f4: c2 26 20 1c st %g1, [ %i0 + 0x1c ]
if (length)
4000d4f8: b4 a6 80 1d subcc %i2, %i5, %i2
4000d4fc: 12 80 00 29 bne 4000d5a0 <rtems_rtl_obj_comp_read+0x224>
4000d500: c4 26 20 24 st %g2, [ %i0 + 0x24 ]
}
}
return true;
4000d504: b0 10 20 01 mov 1, %i0
4000d508: b0 0e 20 ff and %i0, 0xff, %i0
}
4000d50c: 81 c7 e0 08 ret
4000d510: 81 e8 00 00 restore
rtems_rtl_set_error (EINVAL, "bad compression type");
4000d514: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
4000d518: 7f ff fa 35 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000d51c: 92 12 61 60 or %o1, 0x160, %o1
<== NOT EXECUTED
return false;
4000d520: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000d524: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
}
4000d528: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d52c: 81 e8 00 00 restore
<== NOT EXECUTED
memcpy (comp->buffer, input, in_length);
4000d530: d2 07 bf f8 ld [ %fp + -8 ], %o1
<== NOT EXECUTED
4000d534: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
<== NOT EXECUTED
4000d538: 40 00 36 0b call 4001ad64 <memcpy>
<== NOT EXECUTED
4000d53c: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
break;
4000d540: 10 bf ff d1 b 4000d484 <rtems_rtl_obj_comp_read+0x108>
<== NOT EXECUTED
4000d544: d0 07 bf fc ld [ %fp + -4 ], %o0
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "not open");
4000d548: 13 10 00 c4 sethi %hi(0x40031000), %o1
<== NOT EXECUTED
return false;
4000d54c: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "not open");
4000d550: 92 12 61 10 or %o1, 0x110, %o1
<== NOT EXECUTED
4000d554: 7f ff fa 26 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000d558: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
}
4000d55c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d560: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rtl_set_error (EIO, "compressed read failed: bs=%u in=%zu",
4000d564: 13 10 00 c4 sethi %hi(0x40031000), %o1
<== NOT EXECUTED
4000d568: 90 10 20 05 mov 5, %o0
<== NOT EXECUTED
4000d56c: 92 12 61 20 or %o1, 0x120, %o1
<== NOT EXECUTED
4000d570: 7f ff fa 1f call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000d574: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000d578: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
4000d57c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d580: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rtl_set_error (EBADF, "decompression failed");
4000d584: 13 10 00 c4 sethi %hi(0x40031000), %o1
<== NOT EXECUTED
return false;
4000d588: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (EBADF, "decompression failed");
4000d58c: 7f ff fa 18 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000d590: 92 12 61 48 or %o1, 0x148, %o1
<== NOT EXECUTED
4000d594: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
4000d598: 81 c7 e0 08 ret
<== NOT EXECUTED
4000d59c: 81 e8 00 00 restore
<== NOT EXECUTED
bin += buffer_level;
4000d5a0: 10 bf ff 8c b 4000d3d0 <rtems_rtl_obj_comp_read+0x54>
4000d5a4: b2 06 40 1d add %i1, %i5, %i1
4000c404 <rtems_rtl_obj_decompress>:
rtems_rtl_obj_cache* cache,
int fd,
int compression,
off_t offset)
{
if (!rtl)
4000c404: 03 10 00 d8 sethi %hi(0x40036000), %g1
4000c408: c2 00 61 e4 ld [ %g1 + 0x1e4 ], %g1 ! 400361e4 <rtl>
4000c40c: 80 a0 60 00 cmp %g1, 0
4000c410: 02 80 00 07 be 4000c42c <rtems_rtl_obj_decompress+0x28>
<== NEVER TAKEN
4000c414: 82 00 60 f8 add %g1, 0xf8, %g1
{
*decomp = NULL;
}
else
{
*decomp = &rtl->decomp;
4000c418: c2 22 00 00 st %g1, [ %o0 ]
rtems_rtl_obj_comp_set (*decomp, cache, fd, compression, offset);
4000c41c: 90 10 00 01 mov %g1, %o0
4000c420: 82 13 c0 00 mov %o7, %g1
4000c424: 40 00 03 cf call 4000d360 <rtems_rtl_obj_comp_set>
4000c428: 9e 10 40 00 mov %g1, %o7
}
}
4000c42c: 81 c3 e0 08 retl
<== NOT EXECUTED
4000c430: c0 22 00 00 clr [ %o0 ]
<== NOT EXECUTED
4000e4d8 <rtems_rtl_obj_find_file>:
{
4000e4d8: 9d e3 bf a0 save %sp, -96, %sp
return rtems_rtl_parse_name (name, &(obj->aname), &(obj->oname), &(obj->ooffset));
4000e4dc: 90 10 00 19 mov %i1, %o0
4000e4e0: 96 06 20 20 add %i0, 0x20, %o3
4000e4e4: 94 06 20 18 add %i0, 0x18, %o2
4000e4e8: 7f ff fd dd call 4000dc5c <rtems_rtl_parse_name>
4000e4ec: 92 06 20 1c add %i0, 0x1c, %o1
if (!rtems_rtl_obj_parse_name (obj, name))
4000e4f0: 80 a2 20 00 cmp %o0, 0
4000e4f4: 02 80 00 12 be 4000e53c <rtems_rtl_obj_find_file+0x64>
<== NEVER TAKEN
4000e4f8: ba 10 00 08 mov %o0, %i5
4000e4fc: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
if (rtems_rtl_obj_aname_valid (obj))
4000e500: 80 a7 60 00 cmp %i5, 0
4000e504: 02 80 00 1a be 4000e56c <rtems_rtl_obj_find_file+0x94>
<== ALWAYS TAKEN
4000e508: 01 00 00 00 nop
rtl = rtems_rtl_lock ();
4000e50c: 7f ff f7 ca call 4000c434 <rtems_rtl_lock>
<== NOT EXECUTED
4000e510: 01 00 00 00 nop
<== NOT EXECUTED
if (!rtems_rtl_find_file (pname, rtl->paths, &obj->fname, &obj->fsize))
4000e514: d2 02 20 70 ld [ %o0 + 0x70 ], %o1
<== NOT EXECUTED
4000e518: 96 06 20 28 add %i0, 0x28, %o3
<== NOT EXECUTED
4000e51c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000e520: 7f ff f6 5b call 4000be8c <rtems_rtl_find_file>
<== NOT EXECUTED
4000e524: 94 06 20 14 add %i0, 0x14, %o2
<== NOT EXECUTED
4000e528: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e52c: 02 80 00 07 be 4000e548 <rtems_rtl_obj_find_file+0x70>
<== NOT EXECUTED
4000e530: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
rtems_rtl_unlock ();
4000e534: 7f ff f8 c5 call 4000c848 <rtems_rtl_unlock>
4000e538: 01 00 00 00 nop
}
4000e53c: b0 0f 60 ff and %i5, 0xff, %i0
4000e540: 81 c7 e0 08 ret
4000e544: 81 e8 00 00 restore
rtems_rtl_set_error (ENOENT, "file not found");
4000e548: 90 10 20 02 mov 2, %o0
<== NOT EXECUTED
4000e54c: 13 10 00 c4 sethi %hi(0x40031000), %o1
<== NOT EXECUTED
4000e550: 92 12 63 48 or %o1, 0x348, %o1 ! 40031348 <reloc_target_flags+0x5e0>
<== NOT EXECUTED
4000e554: 7f ff f6 26 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000e558: b0 0f 60 ff and %i5, 0xff, %i0
<== NOT EXECUTED
rtems_rtl_unlock ();
4000e55c: 7f ff f8 bb call 4000c848 <rtems_rtl_unlock>
<== NOT EXECUTED
4000e560: 01 00 00 00 nop
<== NOT EXECUTED
}
4000e564: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e568: 81 e8 00 00 restore
<== NOT EXECUTED
rtl = rtems_rtl_lock ();
4000e56c: 7f ff f7 b2 call 4000c434 <rtems_rtl_lock>
4000e570: fa 06 20 18 ld [ %i0 + 0x18 ], %i5
if (!rtems_rtl_find_file (pname, rtl->paths, &obj->fname, &obj->fsize))
4000e574: d2 02 20 70 ld [ %o0 + 0x70 ], %o1
4000e578: 96 06 20 28 add %i0, 0x28, %o3
4000e57c: 90 10 00 1d mov %i5, %o0
4000e580: 7f ff f6 43 call 4000be8c <rtems_rtl_find_file>
4000e584: 94 06 20 14 add %i0, 0x14, %o2
4000e588: 80 a2 20 00 cmp %o0, 0
4000e58c: 12 bf ff ea bne 4000e534 <rtems_rtl_obj_find_file+0x5c>
<== ALWAYS TAKEN
4000e590: ba 10 00 08 mov %o0, %i5
rtems_rtl_set_error (ENOENT, "file not found");
4000e594: 10 bf ff ee b 4000e54c <rtems_rtl_obj_find_file+0x74>
<== NOT EXECUTED
4000e598: 90 10 20 02 mov 2, %o0
<== NOT EXECUTED
4000db40 <rtems_rtl_obj_free>:
{
4000db40: 9d e3 bf a0 save %sp, -96, %sp
if (obj->users || ((obj->flags & RTEMS_RTL_OBJ_LOCKED) != 0))
4000db44: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4000db48: 80 a0 60 00 cmp %g1, 0
4000db4c: 12 80 00 39 bne 4000dc30 <rtems_rtl_obj_free+0xf0>
<== NEVER TAKEN
4000db50: 90 10 20 16 mov 0x16, %o0
4000db54: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000db58: 80 88 60 01 btst 1, %g1
4000db5c: 12 80 00 36 bne 4000dc34 <rtems_rtl_obj_free+0xf4>
<== NEVER TAKEN
4000db60: 13 10 00 c4 sethi %hi(0x40031000), %o1
if (!rtems_chain_is_node_off_chain (&obj->link))
4000db64: c2 06 00 00 ld [ %i0 ], %g1
4000db68: 80 a0 60 00 cmp %g1, 0
4000db6c: 02 80 00 05 be 4000db80 <rtems_rtl_obj_free+0x40>
<== NEVER TAKEN
4000db70: 92 06 20 5c add %i0, 0x5c, %o1
rtems_chain_extract (&obj->link);
4000db74: 40 00 11 78 call 40012154 <rtems_chain_extract>
4000db78: 90 10 00 18 mov %i0, %o0
rtems_rtl_alloc_module_del (&obj->text_base, &obj->const_base, &obj->eh_base,
4000db7c: 92 06 20 5c add %i0, 0x5c, %o1
4000db80: 98 06 20 6c add %i0, 0x6c, %o4
4000db84: 96 06 20 68 add %i0, 0x68, %o3
4000db88: 94 06 20 60 add %i0, 0x60, %o2
4000db8c: 7f ff f2 70 call 4000a54c <rtems_rtl_alloc_module_del>
4000db90: 90 06 20 54 add %i0, 0x54, %o0
rtems_rtl_symbol_obj_erase (obj);
4000db94: 40 00 0a 75 call 40010568 <rtems_rtl_symbol_obj_erase>
4000db98: 90 10 00 18 mov %i0, %o0
4000db9c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1
if (rtems_rtl_obj_oname_valid (obj))
4000dba0: 80 a2 60 00 cmp %o1, 0
4000dba4: 22 80 00 05 be,a 4000dbb8 <rtems_rtl_obj_free+0x78>
<== NEVER TAKEN
4000dba8: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
<== NOT EXECUTED
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_OBJECT, (void*) obj->oname);
4000dbac: 7f ff f2 47 call 4000a4c8 <rtems_rtl_alloc_del>
4000dbb0: 90 10 20 00 clr %o0
4000dbb4: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
if (rtems_rtl_obj_aname_valid (obj))
4000dbb8: 80 a2 60 00 cmp %o1, 0
4000dbbc: 22 80 00 05 be,a 4000dbd0 <rtems_rtl_obj_free+0x90>
<== ALWAYS TAKEN
4000dbc0: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_OBJECT, (void*) obj->aname);
4000dbc4: 7f ff f2 41 call 4000a4c8 <rtems_rtl_alloc_del>
<== NOT EXECUTED
4000dbc8: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000dbcc: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
<== NOT EXECUTED
if (rtems_rtl_obj_fname_valid (obj))
4000dbd0: 80 a2 60 00 cmp %o1, 0
4000dbd4: 22 80 00 05 be,a 4000dbe8 <rtems_rtl_obj_free+0xa8>
<== NEVER TAKEN
4000dbd8: d0 06 20 80 ld [ %i0 + 0x80 ], %o0
<== NOT EXECUTED
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_OBJECT, (void*) obj->fname);
4000dbdc: 7f ff f2 3b call 4000a4c8 <rtems_rtl_alloc_del>
4000dbe0: 90 10 20 00 clr %o0
if (obj->sec_num)
4000dbe4: d0 06 20 80 ld [ %i0 + 0x80 ], %o0
4000dbe8: 80 a2 20 00 cmp %o0, 0
4000dbec: 22 80 00 05 be,a 4000dc00 <rtems_rtl_obj_free+0xc0>
4000dbf0: d2 06 20 88 ld [ %i0 + 0x88 ], %o1
free (obj->sec_num);
4000dbf4: 7f ff e6 38 call 400074d4 <free>
4000dbf8: 01 00 00 00 nop
if (obj->linkmap)
4000dbfc: d2 06 20 88 ld [ %i0 + 0x88 ], %o1
4000dc00: 80 a2 60 00 cmp %o1, 0
4000dc04: 22 80 00 05 be,a 4000dc18 <rtems_rtl_obj_free+0xd8>
<== NEVER TAKEN
4000dc08: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_OBJECT, (void*) obj->linkmap);
4000dc0c: 7f ff f2 2f call 4000a4c8 <rtems_rtl_alloc_del>
4000dc10: 90 10 20 00 clr %o0
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_OBJECT, obj);
4000dc14: 92 10 00 18 mov %i0, %o1
4000dc18: 90 10 20 00 clr %o0
4000dc1c: 7f ff f2 2b call 4000a4c8 <rtems_rtl_alloc_del>
4000dc20: b0 10 20 01 mov 1, %i0
}
4000dc24: b0 0e 20 01 and %i0, 1, %i0
4000dc28: 81 c7 e0 08 ret
4000dc2c: 81 e8 00 00 restore
rtems_rtl_set_error (EINVAL, "cannot free obj still in use");
4000dc30: 13 10 00 c4 sethi %hi(0x40031000), %o1
<== NOT EXECUTED
return false;
4000dc34: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "cannot free obj still in use");
4000dc38: 92 12 62 08 or %o1, 0x208, %o1
<== NOT EXECUTED
4000dc3c: 7f ff f8 6c call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000dc40: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
}
4000dc44: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dc48: 81 e8 00 00 restore
<== NOT EXECUTED
4000ec58 <rtems_rtl_obj_load>:
return false;
}
bool
rtems_rtl_obj_load (rtems_rtl_obj* obj)
{
4000ec58: 9d e3 bf a0 save %sp, -96, %sp
4000ec5c: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
int fd;
if (!rtems_rtl_obj_fname_valid (obj))
4000ec60: 80 a2 20 00 cmp %o0, 0
4000ec64: 22 80 00 24 be,a 4000ecf4 <rtems_rtl_obj_load+0x9c>
<== NEVER TAKEN
4000ec68: 90 10 20 0c mov 0xc, %o0
<== NOT EXECUTED
{
rtems_rtl_set_error (ENOMEM, "invalid object file name path");
return false;
}
fd = open (rtems_rtl_obj_fname (obj), O_RDONLY);
4000ec6c: 7f ff e5 cb call 40008398 <open>
4000ec70: 92 10 20 00 clr %o1
if (fd < 0)
4000ec74: ba 92 20 00 orcc %o0, 0, %i5
4000ec78: 06 80 00 26 bl 4000ed10 <rtems_rtl_obj_load+0xb8>
<== NEVER TAKEN
4000ec7c: 90 10 20 0c mov 0xc, %o0
/*
* Find the object file in the archive if it is an archive that
* has been opened.
*/
if (rtems_rtl_obj_aname_valid (obj))
4000ec80: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4000ec84: 80 a0 60 00 cmp %g1, 0
4000ec88: 02 80 00 07 be 4000eca4 <rtems_rtl_obj_load+0x4c>
<== ALWAYS TAKEN
4000ec8c: 92 10 00 1d mov %i5, %o1
{
if (!rtems_rtl_obj_archive_find (obj, fd))
4000ec90: 7f ff fc b1 call 4000df54 <rtems_rtl_obj_archive_find>
<== NOT EXECUTED
4000ec94: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000ec98: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000ec9c: 02 80 00 24 be 4000ed2c <rtems_rtl_obj_load+0xd4>
<== NOT EXECUTED
4000eca0: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
if (loaders[l].check (obj, fd))
4000eca4: 92 10 00 1d mov %i5, %o1
4000eca8: 40 00 00 c8 call 4000efc8 <rtems_rtl_rap_file_check>
4000ecac: 90 10 00 18 mov %i0, %o0
4000ecb0: 80 a2 20 00 cmp %o0, 0
4000ecb4: 12 80 00 23 bne 4000ed40 <rtems_rtl_obj_load+0xe8>
4000ecb8: 92 10 00 1d mov %i5, %o1
4000ecbc: 7f ff f2 44 call 4000b5cc <rtems_rtl_elf_file_check>
4000ecc0: 90 10 00 18 mov %i0, %o0
4000ecc4: 80 a2 20 00 cmp %o0, 0
4000ecc8: 12 80 00 36 bne 4000eda0 <rtems_rtl_obj_load+0x148>
<== ALWAYS TAKEN
4000eccc: 13 10 00 c5 sethi %hi(0x40031400), %o1
rtems_rtl_set_error (ENOENT, "no format loader found");
4000ecd0: 90 10 20 02 mov 2, %o0
<== NOT EXECUTED
4000ecd4: 7f ff f4 46 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000ecd8: 92 12 60 d8 or %o1, 0xd8, %o1
<== NOT EXECUTED
/*
* Call the format specific loader.
*/
if (!rtems_rtl_obj_file_load (obj, fd))
{
close (fd);
4000ecdc: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000ece0: 7f ff e1 8f call 4000731c <close>
<== NOT EXECUTED
4000ece4: b8 10 20 00 clr %i4
<== NOT EXECUTED
}
close (fd);
return true;
}
4000ece8: b0 0f 20 ff and %i4, 0xff, %i0
<== NOT EXECUTED
4000ecec: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ecf0: 81 e8 00 00 restore
<== NOT EXECUTED
return false;
4000ecf4: b8 10 20 00 clr %i4
<== NOT EXECUTED
rtems_rtl_set_error (ENOMEM, "invalid object file name path");
4000ecf8: 13 10 00 c5 sethi %hi(0x40031400), %o1
<== NOT EXECUTED
}
4000ecfc: b0 0f 20 ff and %i4, 0xff, %i0
<== NOT EXECUTED
rtems_rtl_set_error (ENOMEM, "invalid object file name path");
4000ed00: 7f ff f4 3b call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000ed04: 92 12 60 a0 or %o1, 0xa0, %o1
<== NOT EXECUTED
}
4000ed08: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ed0c: 81 e8 00 00 restore
<== NOT EXECUTED
return false;
4000ed10: b8 10 20 00 clr %i4
<== NOT EXECUTED
rtems_rtl_set_error (ENOMEM, "opening for object file");
4000ed14: 13 10 00 c5 sethi %hi(0x40031400), %o1
<== NOT EXECUTED
}
4000ed18: b0 0f 20 ff and %i4, 0xff, %i0
<== NOT EXECUTED
rtems_rtl_set_error (ENOMEM, "opening for object file");
4000ed1c: 7f ff f4 34 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000ed20: 92 12 60 c0 or %o1, 0xc0, %o1
<== NOT EXECUTED
}
4000ed24: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ed28: 81 e8 00 00 restore
<== NOT EXECUTED
close (fd);
4000ed2c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000ed30: 7f ff e1 7b call 4000731c <close>
<== NOT EXECUTED
4000ed34: b0 0f 20 ff and %i4, 0xff, %i0
<== NOT EXECUTED
}
4000ed38: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ed3c: 81 e8 00 00 restore
<== NOT EXECUTED
if (loaders[l].check (obj, fd))
4000ed40: 03 10 00 3c sethi %hi(0x4000f000), %g1
for (l = 0; l < (sizeof (loaders) / sizeof (rtems_rtl_loader_table)); ++l)
4000ed44: 84 10 20 00 clr %g2
if (loaders[l].check (obj, fd))
4000ed48: 82 10 60 90 or %g1, 0x90, %g1
obj->format = l;
4000ed4c: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
return loaders[l].load (obj, fd);
4000ed50: 92 10 00 1d mov %i5, %o1
4000ed54: 9f c0 40 00 call %g1
4000ed58: 90 10 00 18 mov %i0, %o0
if (!rtems_rtl_obj_file_load (obj, fd))
4000ed5c: 80 a2 20 00 cmp %o0, 0
4000ed60: 02 bf ff df be 4000ecdc <rtems_rtl_obj_load+0x84>
<== NEVER TAKEN
4000ed64: b8 10 00 08 mov %o0, %i4
if (!_rtld_linkmap_add (obj)) /* For GDB */
4000ed68: 7f ff ee 85 call 4000a77c <_rtld_linkmap_add>
4000ed6c: 90 10 00 18 mov %i0, %o0
4000ed70: 80 a2 20 00 cmp %o0, 0
4000ed74: 02 80 00 06 be 4000ed8c <rtems_rtl_obj_load+0x134>
<== NEVER TAKEN
4000ed78: 90 10 00 1d mov %i5, %o0
close (fd);
4000ed7c: 7f ff e1 68 call 4000731c <close>
4000ed80: b0 0f 20 ff and %i4, 0xff, %i0
}
4000ed84: 81 c7 e0 08 ret
4000ed88: 81 e8 00 00 restore
close (fd);
4000ed8c: 7f ff e1 64 call 4000731c <close>
<== NOT EXECUTED
4000ed90: b8 10 20 00 clr %i4
<== NOT EXECUTED
}
4000ed94: b0 0f 20 ff and %i4, 0xff, %i0
<== NOT EXECUTED
4000ed98: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ed9c: 81 e8 00 00 restore
<== NOT EXECUTED
if (loaders[l].check (obj, fd))
4000eda0: 03 10 00 2d sethi %hi(0x4000b400), %g1
for (l = 0; l < (sizeof (loaders) / sizeof (rtems_rtl_loader_table)); ++l)
4000eda4: 84 10 20 01 mov 1, %g2
if (loaders[l].check (obj, fd))
4000eda8: 10 bf ff e9 b 4000ed4c <rtems_rtl_obj_load+0xf4>
4000edac: 82 10 62 90 or %g1, 0x290, %g1
4000e818 <rtems_rtl_obj_load_sections>:
{
4000e818: 9d e3 bf 68 save %sp, -152, %sp
summer.mask = mask;
4000e81c: 82 10 20 01 mov 1, %g1
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e820: ba 06 20 2c add %i0, 0x2c, %i5
4000e824: 2d 10 00 36 sethi %hi(0x4000d800), %l6
summer.mask = mask;
4000e828: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e82c: 92 15 a2 a4 or %l6, 0x2a4, %o1
4000e830: 94 07 bf f8 add %fp, -8, %o2
summer.size = 0;
4000e834: c0 27 bf fc clr [ %fp + -4 ]
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e838: 7f ff ef be call 4000a730 <rtems_rtl_chain_iterate>
4000e83c: 90 10 00 1d mov %i5, %o0
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e840: 39 10 00 35 sethi %hi(0x4000d400), %i4
return summer.size;
4000e844: e0 07 bf fc ld [ %fp + -4 ], %l0
aligner.mask = mask;
4000e848: aa 10 20 02 mov 2, %l5
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e84c: 94 07 bf f8 add %fp, -8, %o2
4000e850: 92 17 21 a8 or %i4, 0x1a8, %o1
aligner.mask = mask;
4000e854: ea 27 bf f8 st %l5, [ %fp + -8 ]
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e858: 90 10 00 1d mov %i5, %o0
4000e85c: 7f ff ef b5 call 4000a730 <rtems_rtl_chain_iterate>
4000e860: c0 27 bf fc clr [ %fp + -4 ]
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e864: 92 15 a2 a4 or %l6, 0x2a4, %o1
return aligner.alignment;
4000e868: e2 07 bf fc ld [ %fp + -4 ], %l1
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e86c: 94 07 bf f8 add %fp, -8, %o2
summer.mask = mask;
4000e870: ea 27 bf f8 st %l5, [ %fp + -8 ]
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e874: 90 10 00 1d mov %i5, %o0
4000e878: 7f ff ef ae call 4000a730 <rtems_rtl_chain_iterate>
4000e87c: c0 27 bf fc clr [ %fp + -4 ]
text_size = rtems_rtl_obj_text_size (obj) + rtems_rtl_obj_const_alignment (obj);
4000e880: a2 04 40 10 add %l1, %l0, %l1
aligner.mask = mask;
4000e884: a8 10 20 10 mov 0x10, %l4
return summer.size;
4000e888: e0 07 bf fc ld [ %fp + -4 ], %l0
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e88c: 94 07 bf f8 add %fp, -8, %o2
4000e890: 92 17 21 a8 or %i4, 0x1a8, %o1
aligner.mask = mask;
4000e894: e8 27 bf f8 st %l4, [ %fp + -8 ]
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e898: 90 10 00 1d mov %i5, %o0
4000e89c: 7f ff ef a5 call 4000a730 <rtems_rtl_chain_iterate>
4000e8a0: c0 27 bf fc clr [ %fp + -4 ]
return aligner.alignment;
4000e8a4: c2 07 bf fc ld [ %fp + -4 ], %g1
const_size = rtems_rtl_obj_const_size (obj) + rtems_rtl_obj_eh_alignment (obj);
4000e8a8: 82 00 40 10 add %g1, %l0, %g1
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e8ac: 92 15 a2 a4 or %l6, 0x2a4, %o1
const_size = rtems_rtl_obj_const_size (obj) + rtems_rtl_obj_eh_alignment (obj);
4000e8b0: c2 27 bf f4 st %g1, [ %fp + -12 ]
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e8b4: 94 07 bf f8 add %fp, -8, %o2
summer.mask = mask;
4000e8b8: e8 27 bf f8 st %l4, [ %fp + -8 ]
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e8bc: 90 10 00 1d mov %i5, %o0
4000e8c0: 7f ff ef 9c call 4000a730 <rtems_rtl_chain_iterate>
4000e8c4: c0 27 bf fc clr [ %fp + -4 ]
aligner.mask = mask;
4000e8c8: a6 10 20 04 mov 4, %l3
return summer.size;
4000e8cc: e0 07 bf fc ld [ %fp + -4 ], %l0
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e8d0: 94 07 bf f8 add %fp, -8, %o2
4000e8d4: 92 17 21 a8 or %i4, 0x1a8, %o1
aligner.mask = mask;
4000e8d8: e6 27 bf f8 st %l3, [ %fp + -8 ]
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e8dc: 90 10 00 1d mov %i5, %o0
4000e8e0: 7f ff ef 94 call 4000a730 <rtems_rtl_chain_iterate>
4000e8e4: c0 27 bf fc clr [ %fp + -4 ]
return aligner.alignment;
4000e8e8: c2 07 bf fc ld [ %fp + -4 ], %g1
eh_size = rtems_rtl_obj_eh_size (obj) + rtems_rtl_obj_data_alignment (obj);
4000e8ec: a0 00 40 10 add %g1, %l0, %l0
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e8f0: 92 15 a2 a4 or %l6, 0x2a4, %o1
4000e8f4: 94 07 bf f8 add %fp, -8, %o2
summer.mask = mask;
4000e8f8: e6 27 bf f8 st %l3, [ %fp + -8 ]
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e8fc: 90 10 00 1d mov %i5, %o0
4000e900: 7f ff ef 8c call 4000a730 <rtems_rtl_chain_iterate>
4000e904: c0 27 bf fc clr [ %fp + -4 ]
aligner.mask = mask;
4000e908: a4 10 20 08 mov 8, %l2
return summer.size;
4000e90c: ee 07 bf fc ld [ %fp + -4 ], %l7
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e910: 94 07 bf f8 add %fp, -8, %o2
4000e914: 92 17 21 a8 or %i4, 0x1a8, %o1
aligner.mask = mask;
4000e918: e4 27 bf f8 st %l2, [ %fp + -8 ]
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e91c: 90 10 00 1d mov %i5, %o0
4000e920: 7f ff ef 84 call 4000a730 <rtems_rtl_chain_iterate>
4000e924: c0 27 bf fc clr [ %fp + -4 ]
return aligner.alignment;
4000e928: c2 07 bf fc ld [ %fp + -4 ], %g1
data_size = rtems_rtl_obj_data_size (obj) + rtems_rtl_obj_bss_alignment (obj);
4000e92c: ae 00 40 17 add %g1, %l7, %l7
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e930: 92 15 a2 a4 or %l6, 0x2a4, %o1
4000e934: 94 07 bf f8 add %fp, -8, %o2
summer.mask = mask;
4000e938: e4 27 bf f8 st %l2, [ %fp + -8 ]
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000e93c: 90 10 00 1d mov %i5, %o0
4000e940: 7f ff ef 7c call 4000a730 <rtems_rtl_chain_iterate>
4000e944: c0 27 bf fc clr [ %fp + -4 ]
return summer.size;
4000e948: ec 07 bf fc ld [ %fp + -4 ], %l6
obj->text_size = text_size;
4000e94c: e2 26 20 58 st %l1, [ %i0 + 0x58 ]
if (!rtems_rtl_alloc_module_new (&obj->text_base, text_size,
4000e950: 84 06 20 68 add %i0, 0x68, %g2
obj->eh_size = eh_size;
4000e954: e0 26 20 64 st %l0, [ %i0 + 0x64 ]
if (!rtems_rtl_alloc_module_new (&obj->text_base, text_size,
4000e958: 86 06 20 6c add %i0, 0x6c, %g3
obj->bss_size = bss_size;
4000e95c: ec 26 20 70 st %l6, [ %i0 + 0x70 ]
if (!rtems_rtl_alloc_module_new (&obj->text_base, text_size,
4000e960: 90 06 20 54 add %i0, 0x54, %o0
4000e964: ec 23 a0 68 st %l6, [ %sp + 0x68 ]
4000e968: 94 06 20 5c add %i0, 0x5c, %o2
4000e96c: c6 23 a0 64 st %g3, [ %sp + 0x64 ]
4000e970: 98 06 20 60 add %i0, 0x60, %o4
4000e974: ee 23 a0 60 st %l7, [ %sp + 0x60 ]
4000e978: 9a 10 00 10 mov %l0, %o5
4000e97c: c4 23 a0 5c st %g2, [ %sp + 0x5c ]
4000e980: 92 10 00 11 mov %l1, %o1
4000e984: d6 07 bf f4 ld [ %fp + -12 ], %o3
4000e988: c4 27 bf e0 st %g2, [ %fp + -32 ]
4000e98c: c6 27 bf dc st %g3, [ %fp + -36 ]
4000e990: d0 27 bf ec st %o0, [ %fp + -20 ]
4000e994: d4 27 bf e8 st %o2, [ %fp + -24 ]
4000e998: 7f ff ef 04 call 4000a5a8 <rtems_rtl_alloc_module_new>
4000e99c: d8 27 bf e4 st %o4, [ %fp + -28 ]
4000e9a0: 80 a2 20 00 cmp %o0, 0
4000e9a4: 02 80 00 58 be 4000eb04 <rtems_rtl_obj_load_sections+0x2ec>
<== NEVER TAKEN
4000e9a8: d0 2f bf f3 stb %o0, [ %fp + -13 ]
obj->exec_size = text_size + const_size + eh_size + data_size + bss_size;
4000e9ac: c2 07 bf f4 ld [ %fp + -12 ], %g1
4000e9b0: 84 04 40 01 add %l1, %g1, %g2
4000e9b4: 84 00 80 16 add %g2, %l6, %g2
4000e9b8: 84 00 80 10 add %g2, %l0, %g2
4000e9bc: 84 00 80 17 add %g2, %l7, %g2
4000e9c0: c4 26 20 74 st %g2, [ %i0 + 0x74 ]
if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD_SECT))
4000e9c4: 40 00 07 10 call 40010604 <rtems_rtl_trace>
4000e9c8: 90 10 21 00 mov 0x100, %o0
4000e9cc: 80 a2 20 00 cmp %o0, 0
4000e9d0: 12 80 00 55 bne 4000eb24 <rtems_rtl_obj_load_sections+0x30c>
4000e9d4: 82 10 20 01 mov 1, %g1
rtems_rtl_obj_sections_link_order (RTEMS_RTL_OBJ_SECT_TEXT, obj);
4000e9d8: 90 10 20 01 mov 1, %o0
4000e9dc: 7f ff fb 38 call 4000d6bc <rtems_rtl_obj_sections_link_order>
4000e9e0: 92 10 00 18 mov %i0, %o1
rtems_rtl_obj_sections_link_order (RTEMS_RTL_OBJ_SECT_CONST, obj);
4000e9e4: 92 10 00 18 mov %i0, %o1
4000e9e8: 7f ff fb 35 call 4000d6bc <rtems_rtl_obj_sections_link_order>
4000e9ec: 90 10 20 02 mov 2, %o0
rtems_rtl_obj_sections_link_order (RTEMS_RTL_OBJ_SECT_EH, obj);
4000e9f0: 92 10 00 18 mov %i0, %o1
4000e9f4: 7f ff fb 32 call 4000d6bc <rtems_rtl_obj_sections_link_order>
4000e9f8: 90 10 20 10 mov 0x10, %o0
rtems_rtl_obj_sections_link_order (RTEMS_RTL_OBJ_SECT_DATA, obj);
4000e9fc: 92 10 00 18 mov %i0, %o1
4000ea00: 7f ff fb 2f call 4000d6bc <rtems_rtl_obj_sections_link_order>
4000ea04: 90 10 20 04 mov 4, %o0
if (!rtems_rtl_obj_sections_loader (RTEMS_RTL_OBJ_SECT_TEXT,
4000ea08: d6 06 20 54 ld [ %i0 + 0x54 ], %o3
4000ea0c: 9a 10 00 1b mov %i3, %o5
4000ea10: 98 10 00 1a mov %i2, %o4
4000ea14: 94 10 00 19 mov %i1, %o2
4000ea18: 92 10 00 18 mov %i0, %o1
4000ea1c: 7f ff fb 7d call 4000d810 <rtems_rtl_obj_sections_loader>
4000ea20: 90 10 20 01 mov 1, %o0
4000ea24: 80 a2 20 00 cmp %o0, 0
4000ea28: 32 80 00 0d bne,a 4000ea5c <rtems_rtl_obj_load_sections+0x244>
<== ALWAYS TAKEN
4000ea2c: d6 06 20 5c ld [ %i0 + 0x5c ], %o3
rtems_rtl_alloc_module_del (&obj->text_base, &obj->const_base, &obj->eh_base,
4000ea30: d8 07 bf dc ld [ %fp + -36 ], %o4
<== NOT EXECUTED
4000ea34: d6 07 bf e0 ld [ %fp + -32 ], %o3
<== NOT EXECUTED
4000ea38: d4 07 bf e4 ld [ %fp + -28 ], %o2
<== NOT EXECUTED
4000ea3c: d2 07 bf e8 ld [ %fp + -24 ], %o1
<== NOT EXECUTED
4000ea40: d0 07 bf ec ld [ %fp + -20 ], %o0
<== NOT EXECUTED
4000ea44: 7f ff ee c2 call 4000a54c <rtems_rtl_alloc_module_del>
<== NOT EXECUTED
4000ea48: c0 2f bf f3 clrb [ %fp + -13 ]
<== NOT EXECUTED
obj->exec_size = 0;
4000ea4c: c0 26 20 74 clr [ %i0 + 0x74 ]
<== NOT EXECUTED
}
4000ea50: f0 0f bf f3 ldub [ %fp + -13 ], %i0
<== NOT EXECUTED
4000ea54: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ea58: 81 e8 00 00 restore
<== NOT EXECUTED
!rtems_rtl_obj_sections_loader (RTEMS_RTL_OBJ_SECT_CONST,
4000ea5c: 9a 10 00 1b mov %i3, %o5
4000ea60: 98 10 00 1a mov %i2, %o4
4000ea64: 94 10 00 19 mov %i1, %o2
4000ea68: 92 10 00 18 mov %i0, %o1
4000ea6c: 7f ff fb 69 call 4000d810 <rtems_rtl_obj_sections_loader>
4000ea70: 90 10 20 02 mov 2, %o0
obj, fd, obj->text_base, handler, data) ||
4000ea74: 80 a2 20 00 cmp %o0, 0
4000ea78: 02 bf ff ef be 4000ea34 <rtems_rtl_obj_load_sections+0x21c>
<== NEVER TAKEN
4000ea7c: d8 07 bf dc ld [ %fp + -36 ], %o4
!rtems_rtl_obj_sections_loader (RTEMS_RTL_OBJ_SECT_EH,
4000ea80: d6 06 20 60 ld [ %i0 + 0x60 ], %o3
4000ea84: 9a 10 00 1b mov %i3, %o5
4000ea88: 98 10 00 1a mov %i2, %o4
4000ea8c: 94 10 00 19 mov %i1, %o2
4000ea90: 92 10 00 18 mov %i0, %o1
4000ea94: 7f ff fb 5f call 4000d810 <rtems_rtl_obj_sections_loader>
4000ea98: 90 10 20 10 mov 0x10, %o0
obj, fd, obj->const_base, handler, data) ||
4000ea9c: 80 a2 20 00 cmp %o0, 0
4000eaa0: 02 bf ff e5 be 4000ea34 <rtems_rtl_obj_load_sections+0x21c>
<== NEVER TAKEN
4000eaa4: d8 07 bf dc ld [ %fp + -36 ], %o4
!rtems_rtl_obj_sections_loader (RTEMS_RTL_OBJ_SECT_DATA,
4000eaa8: d6 06 20 68 ld [ %i0 + 0x68 ], %o3
4000eaac: 9a 10 00 1b mov %i3, %o5
4000eab0: 98 10 00 1a mov %i2, %o4
4000eab4: 94 10 00 19 mov %i1, %o2
4000eab8: 92 10 00 18 mov %i0, %o1
4000eabc: 7f ff fb 55 call 4000d810 <rtems_rtl_obj_sections_loader>
4000eac0: 90 10 20 04 mov 4, %o0
obj, fd, obj->eh_base, handler, data) ||
4000eac4: 80 a2 20 00 cmp %o0, 0
4000eac8: 02 bf ff db be 4000ea34 <rtems_rtl_obj_load_sections+0x21c>
<== NEVER TAKEN
4000eacc: d8 07 bf dc ld [ %fp + -36 ], %o4
!rtems_rtl_obj_sections_loader (RTEMS_RTL_OBJ_SECT_BSS,
4000ead0: d6 06 20 6c ld [ %i0 + 0x6c ], %o3
4000ead4: 9a 10 00 1b mov %i3, %o5
4000ead8: 98 10 00 1a mov %i2, %o4
4000eadc: 94 10 00 19 mov %i1, %o2
4000eae0: 92 10 00 18 mov %i0, %o1
4000eae4: 7f ff fb 4b call 4000d810 <rtems_rtl_obj_sections_loader>
4000eae8: 90 10 20 08 mov 8, %o0
obj, fd, obj->data_base, handler, data) ||
4000eaec: 80 a2 20 00 cmp %o0, 0
4000eaf0: 02 bf ff d1 be 4000ea34 <rtems_rtl_obj_load_sections+0x21c>
<== NEVER TAKEN
4000eaf4: d8 07 bf dc ld [ %fp + -36 ], %o4
4000eaf8: f0 0f bf f3 ldub [ %fp + -13 ], %i0
4000eafc: 81 c7 e0 08 ret
4000eb00: 81 e8 00 00 restore
obj->exec_size = 0;
4000eb04: c0 26 20 74 clr [ %i0 + 0x74 ]
<== NOT EXECUTED
rtems_rtl_set_error (ENOMEM, "no memory to load obj");
4000eb08: 90 10 20 0c mov 0xc, %o0
<== NOT EXECUTED
4000eb0c: 13 10 00 c4 sethi %hi(0x40031000), %o1
<== NOT EXECUTED
4000eb10: 7f ff f4 b7 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000eb14: 92 12 63 98 or %o1, 0x398, %o1 ! 40031398 <reloc_target_flags+0x630>
<== NOT EXECUTED
}
4000eb18: f0 0f bf f3 ldub [ %fp + -13 ], %i0
<== NOT EXECUTED
4000eb1c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000eb20: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtl: load sect: text - b:%p s:%zi a:%" PRIu32 "\n",
4000eb24: c4 06 20 54 ld [ %i0 + 0x54 ], %g2
aligner.mask = mask;
4000eb28: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000eb2c: 94 07 bf f8 add %fp, -8, %o2
printf ("rtl: load sect: text - b:%p s:%zi a:%" PRIu32 "\n",
4000eb30: c4 27 bf d8 st %g2, [ %fp + -40 ]
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000eb34: 92 17 21 a8 or %i4, 0x1a8, %o1
4000eb38: 90 10 00 1d mov %i5, %o0
4000eb3c: 7f ff ee fd call 4000a730 <rtems_rtl_chain_iterate>
4000eb40: c0 27 bf fc clr [ %fp + -4 ]
printf ("rtl: load sect: text - b:%p s:%zi a:%" PRIu32 "\n",
4000eb44: c4 07 bf d8 ld [ %fp + -40 ], %g2
4000eb48: d6 07 bf fc ld [ %fp + -4 ], %o3
4000eb4c: 92 10 00 02 mov %g2, %o1
4000eb50: 94 10 00 11 mov %l1, %o2
4000eb54: 11 10 00 c4 sethi %hi(0x40031000), %o0
4000eb58: 40 00 27 7c call 40018948 <__wrap_printf>
4000eb5c: 90 12 23 b0 or %o0, 0x3b0, %o0 ! 400313b0 <reloc_target_flags+0x648>
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000eb60: 94 07 bf f8 add %fp, -8, %o2
printf ("rtl: load sect: const - b:%p s:%zi a:%" PRIu32 "\n",
4000eb64: e2 06 20 5c ld [ %i0 + 0x5c ], %l1
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000eb68: 92 17 21 a8 or %i4, 0x1a8, %o1
aligner.mask = mask;
4000eb6c: ea 27 bf f8 st %l5, [ %fp + -8 ]
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000eb70: 90 10 00 1d mov %i5, %o0
4000eb74: 7f ff ee ef call 4000a730 <rtems_rtl_chain_iterate>
4000eb78: c0 27 bf fc clr [ %fp + -4 ]
printf ("rtl: load sect: const - b:%p s:%zi a:%" PRIu32 "\n",
4000eb7c: d6 07 bf fc ld [ %fp + -4 ], %o3
4000eb80: d4 07 bf f4 ld [ %fp + -12 ], %o2
4000eb84: 92 10 00 11 mov %l1, %o1
4000eb88: 11 10 00 c4 sethi %hi(0x40031000), %o0
4000eb8c: 40 00 27 6f call 40018948 <__wrap_printf>
4000eb90: 90 12 23 e0 or %o0, 0x3e0, %o0 ! 400313e0 <reloc_target_flags+0x678>
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000eb94: 94 07 bf f8 add %fp, -8, %o2
printf ("rtl: load sect: eh - b:%p s:%zi a:%" PRIu32 "\n",
4000eb98: e2 06 20 60 ld [ %i0 + 0x60 ], %l1
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000eb9c: 92 17 21 a8 or %i4, 0x1a8, %o1
aligner.mask = mask;
4000eba0: e8 27 bf f8 st %l4, [ %fp + -8 ]
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000eba4: 90 10 00 1d mov %i5, %o0
4000eba8: 7f ff ee e2 call 4000a730 <rtems_rtl_chain_iterate>
4000ebac: c0 27 bf fc clr [ %fp + -4 ]
printf ("rtl: load sect: eh - b:%p s:%zi a:%" PRIu32 "\n",
4000ebb0: d6 07 bf fc ld [ %fp + -4 ], %o3
4000ebb4: 94 10 00 10 mov %l0, %o2
4000ebb8: 92 10 00 11 mov %l1, %o1
4000ebbc: 11 10 00 c5 sethi %hi(0x40031400), %o0
4000ebc0: 40 00 27 62 call 40018948 <__wrap_printf>
4000ebc4: 90 12 20 10 or %o0, 0x10, %o0 ! 40031410 <reloc_target_flags+0x6a8>
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000ebc8: 94 07 bf f8 add %fp, -8, %o2
printf ("rtl: load sect: data - b:%p s:%zi a:%" PRIu32 "\n",
4000ebcc: e0 06 20 68 ld [ %i0 + 0x68 ], %l0
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000ebd0: 92 17 21 a8 or %i4, 0x1a8, %o1
aligner.mask = mask;
4000ebd4: e6 27 bf f8 st %l3, [ %fp + -8 ]
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000ebd8: 90 10 00 1d mov %i5, %o0
4000ebdc: 7f ff ee d5 call 4000a730 <rtems_rtl_chain_iterate>
4000ebe0: c0 27 bf fc clr [ %fp + -4 ]
printf ("rtl: load sect: data - b:%p s:%zi a:%" PRIu32 "\n",
4000ebe4: d6 07 bf fc ld [ %fp + -4 ], %o3
4000ebe8: 94 10 00 17 mov %l7, %o2
4000ebec: 92 10 00 10 mov %l0, %o1
4000ebf0: 11 10 00 c5 sethi %hi(0x40031400), %o0
4000ebf4: 40 00 27 55 call 40018948 <__wrap_printf>
4000ebf8: 90 12 20 40 or %o0, 0x40, %o0 ! 40031440 <reloc_target_flags+0x6d8>
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000ebfc: 94 07 bf f8 add %fp, -8, %o2
printf ("rtl: load sect: bss - b:%p s:%zi a:%" PRIu32 "\n",
4000ec00: e0 06 20 6c ld [ %i0 + 0x6c ], %l0
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000ec04: 92 17 21 a8 or %i4, 0x1a8, %o1
aligner.mask = mask;
4000ec08: e4 27 bf f8 st %l2, [ %fp + -8 ]
rtems_rtl_chain_iterate ((rtems_chain_control*) &obj->sections,
4000ec0c: 90 10 00 1d mov %i5, %o0
4000ec10: 7f ff ee c8 call 4000a730 <rtems_rtl_chain_iterate>
4000ec14: c0 27 bf fc clr [ %fp + -4 ]
printf ("rtl: load sect: bss - b:%p s:%zi a:%" PRIu32 "\n",
4000ec18: d6 07 bf fc ld [ %fp + -4 ], %o3
4000ec1c: 94 10 00 16 mov %l6, %o2
4000ec20: 92 10 00 10 mov %l0, %o1
4000ec24: 11 10 00 c5 sethi %hi(0x40031400), %o0
4000ec28: 40 00 27 48 call 40018948 <__wrap_printf>
4000ec2c: 90 12 20 70 or %o0, 0x70, %o0 ! 40031470 <reloc_target_flags+0x708>
rtems_rtl_obj_sections_link_order (RTEMS_RTL_OBJ_SECT_TEXT, obj);
4000ec30: 10 bf ff 6b b 4000e9dc <rtems_rtl_obj_load_sections+0x1c4>
4000ec34: 90 10 20 01 mov 1, %o0
4000e7b0 <rtems_rtl_obj_load_symbols>:
{
4000e7b0: 9d e3 bf a0 save %sp, -96, %sp
return _Chain_Immutable_head( the_chain )->next;
4000e7b4: fa 06 20 2c ld [ %i0 + 0x2c ], %i5
return &the_chain->Tail.Node;
4000e7b8: b8 06 20 30 add %i0, 0x30, %i4
while (!rtems_chain_is_tail (&obj->sections, node))
4000e7bc: 80 a7 40 1c cmp %i5, %i4
4000e7c0: 22 80 00 13 be,a 4000e80c <rtems_rtl_obj_load_symbols+0x5c>
<== NEVER TAKEN
4000e7c4: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
if ((sect->flags & mask) != 0)
4000e7c8: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
if (!handler (obj, fd, sect, data))
4000e7cc: 94 10 00 1d mov %i5, %o2
4000e7d0: 96 10 00 1b mov %i3, %o3
4000e7d4: 92 10 00 19 mov %i1, %o1
if ((sect->flags & mask) != 0)
4000e7d8: 80 88 60 80 btst 0x80, %g1
4000e7dc: 02 80 00 07 be 4000e7f8 <rtems_rtl_obj_load_symbols+0x48>
4000e7e0: 90 10 00 18 mov %i0, %o0
if (!handler (obj, fd, sect, data))
4000e7e4: 9f c6 80 00 call %i2
4000e7e8: 01 00 00 00 nop
4000e7ec: 80 a2 20 00 cmp %o0, 0
4000e7f0: 22 80 00 08 be,a 4000e810 <rtems_rtl_obj_load_symbols+0x60>
<== NEVER TAKEN
4000e7f4: b0 0a 20 ff and %o0, 0xff, %i0
<== NOT EXECUTED
4000e7f8: fa 07 40 00 ld [ %i5 ], %i5
while (!rtems_chain_is_tail (&obj->sections, node))
4000e7fc: 80 a7 40 1c cmp %i5, %i4
4000e800: 32 bf ff f3 bne,a 4000e7cc <rtems_rtl_obj_load_symbols+0x1c>
4000e804: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
return true;
4000e808: 90 10 20 01 mov 1, %o0
}
4000e80c: b0 0a 20 ff and %o0, 0xff, %i0
4000e810: 81 c7 e0 08 ret
4000e814: 81 e8 00 00 restore
4000e6d0 <rtems_rtl_obj_relocate>:
{
4000e6d0: 9d e3 bf a0 save %sp, -96, %sp
return _Chain_Immutable_head( the_chain )->next;
4000e6d4: fa 06 20 2c ld [ %i0 + 0x2c ], %i5
return &the_chain->Tail.Node;
4000e6d8: b8 06 20 30 add %i0, 0x30, %i4
while (!rtems_chain_is_tail (&obj->sections, node))
4000e6dc: 80 a7 40 1c cmp %i5, %i4
4000e6e0: 22 80 00 13 be,a 4000e72c <rtems_rtl_obj_relocate+0x5c>
<== NEVER TAKEN
4000e6e4: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
if ((sect->flags & mask) != 0)
4000e6e8: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
if (!handler (obj, fd, sect, data))
4000e6ec: 94 10 00 1d mov %i5, %o2
4000e6f0: 96 10 00 1b mov %i3, %o3
4000e6f4: 92 10 00 19 mov %i1, %o1
if ((sect->flags & mask) != 0)
4000e6f8: 80 88 60 60 btst 0x60, %g1
4000e6fc: 02 80 00 07 be 4000e718 <rtems_rtl_obj_relocate+0x48>
4000e700: 90 10 00 18 mov %i0, %o0
if (!handler (obj, fd, sect, data))
4000e704: 9f c6 80 00 call %i2
4000e708: 01 00 00 00 nop
4000e70c: 80 a2 20 00 cmp %o0, 0
4000e710: 22 80 00 08 be,a 4000e730 <rtems_rtl_obj_relocate+0x60>
<== NEVER TAKEN
4000e714: b0 0a 20 ff and %o0, 0xff, %i0
<== NOT EXECUTED
4000e718: fa 07 40 00 ld [ %i5 ], %i5
while (!rtems_chain_is_tail (&obj->sections, node))
4000e71c: 80 a7 40 1c cmp %i5, %i4
4000e720: 32 bf ff f3 bne,a 4000e6ec <rtems_rtl_obj_relocate+0x1c>
4000e724: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
return true;
4000e728: 90 10 20 01 mov 1, %o0
}
4000e72c: b0 0a 20 ff and %o0, 0xff, %i0
4000e730: 81 c7 e0 08 ret
4000e734: 81 e8 00 00 restore
4000b454 <rtems_rtl_obj_relocate_unresolved>:
{
4000b454: 9d e3 bf 90 save %sp, -112, %sp
4000b458: c2 16 20 04 lduh [ %i0 + 4 ], %g1
sect = rtems_rtl_obj_find_section_by_index (reloc->obj, reloc->sect);
4000b45c: d2 16 20 08 lduh [ %i0 + 8 ], %o1
4000b460: d0 06 00 00 ld [ %i0 ], %o0
4000b464: 40 00 0c 90 call 4000e6a4 <rtems_rtl_obj_find_section_by_index>
4000b468: ba 08 60 01 and %g1, 1, %i5
if (!sect)
4000b46c: b8 92 20 00 orcc %o0, 0, %i4
4000b470: 02 80 00 3c be 4000b560 <rtems_rtl_obj_relocate_unresolved+0x10c>
<== NEVER TAKEN
4000b474: 80 a7 60 00 cmp %i5, 0
symvalue = (Elf_Word) (intptr_t) sym->value;
4000b478: f6 06 60 0c ld [ %i1 + 0xc ], %i3
4000b47c: c4 06 20 0c ld [ %i0 + 0xc ], %g2
if (is_rela)
4000b480: 12 80 00 22 bne 4000b508 <rtems_rtl_obj_relocate_unresolved+0xb4>
<== ALWAYS TAKEN
4000b484: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
rel.r_offset = reloc->rel[REL_R_OFFSET];
4000b488: c4 27 bf f4 st %g2, [ %fp + -12 ]
<== NOT EXECUTED
if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
4000b48c: 90 10 20 40 mov 0x40, %o0
<== NOT EXECUTED
4000b490: 40 00 14 5d call 40010604 <rtems_rtl_trace>
<== NOT EXECUTED
4000b494: c2 27 bf f8 st %g1, [ %fp + -8 ]
<== NOT EXECUTED
4000b498: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000b49c: 12 80 00 39 bne 4000b580 <rtems_rtl_obj_relocate_unresolved+0x12c>
<== NOT EXECUTED
4000b4a0: d2 07 bf f8 ld [ %fp + -8 ], %o1
<== NOT EXECUTED
if (!rtems_rtl_elf_relocate_rel (reloc->obj, &rel, sect,
4000b4a4: d8 0e 60 13 ldub [ %i1 + 0x13 ], %o4
<== NOT EXECUTED
4000b4a8: d6 06 60 08 ld [ %i1 + 8 ], %o3
<== NOT EXECUTED
4000b4ac: d0 06 00 00 ld [ %i0 ], %o0
<== NOT EXECUTED
4000b4b0: 9a 10 00 1b mov %i3, %o5
<== NOT EXECUTED
4000b4b4: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
4000b4b8: 40 00 03 7d call 4000c2ac <rtems_rtl_elf_relocate_rel>
<== NOT EXECUTED
4000b4bc: 92 07 bf f4 add %fp, -12, %o1
<== NOT EXECUTED
4000b4c0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000b4c4: 02 80 00 0e be 4000b4fc <rtems_rtl_obj_relocate_unresolved+0xa8>
<== NOT EXECUTED
4000b4c8: 82 10 00 08 mov %o0, %g1
<== NOT EXECUTED
if (reloc->obj->unresolved)
4000b4cc: c4 06 00 00 ld [ %i0 ], %g2
4000b4d0: c2 00 a0 50 ld [ %g2 + 0x50 ], %g1
4000b4d4: 80 a0 60 00 cmp %g1, 0
4000b4d8: 02 80 00 08 be 4000b4f8 <rtems_rtl_obj_relocate_unresolved+0xa4>
<== NEVER TAKEN
4000b4dc: 82 00 7f ff add %g1, -1, %g1
if (!reloc->obj->unresolved)
4000b4e0: 80 a0 60 00 cmp %g1, 0
4000b4e4: 12 80 00 05 bne 4000b4f8 <rtems_rtl_obj_relocate_unresolved+0xa4>
4000b4e8: c2 20 a0 50 st %g1, [ %g2 + 0x50 ]
reloc->obj->flags &= ~RTEMS_RTL_OBJ_UNRESOLVED;
4000b4ec: c2 00 a0 08 ld [ %g2 + 8 ], %g1
4000b4f0: 82 08 7f fd and %g1, -3, %g1
4000b4f4: c2 20 a0 08 st %g1, [ %g2 + 8 ]
return true;
4000b4f8: 82 10 20 01 mov 1, %g1
}
4000b4fc: b0 08 60 ff and %g1, 0xff, %i0
4000b500: 81 c7 e0 08 ret
4000b504: 81 e8 00 00 restore
rela.r_addend = reloc->rel[REL_R_ADDEND];
4000b508: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
rela.r_offset = reloc->rel[REL_R_OFFSET];
4000b50c: c4 27 bf f4 st %g2, [ %fp + -12 ]
if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
4000b510: 90 10 20 40 mov 0x40, %o0
rela.r_info = reloc->rel[REL_R_INFO];
4000b514: c2 27 bf f8 st %g1, [ %fp + -8 ]
if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
4000b518: 40 00 14 3b call 40010604 <rtems_rtl_trace>
4000b51c: c6 27 bf fc st %g3, [ %fp + -4 ]
4000b520: 80 a2 20 00 cmp %o0, 0
4000b524: 12 80 00 20 bne 4000b5a4 <rtems_rtl_obj_relocate_unresolved+0x150>
<== NEVER TAKEN
4000b528: d2 07 bf f8 ld [ %fp + -8 ], %o1
if (!rtems_rtl_elf_relocate_rela (reloc->obj, &rela, sect,
4000b52c: d8 0e 60 13 ldub [ %i1 + 0x13 ], %o4
4000b530: d6 06 60 08 ld [ %i1 + 8 ], %o3
4000b534: d0 06 00 00 ld [ %i0 ], %o0
4000b538: 9a 10 00 1b mov %i3, %o5
4000b53c: 94 10 00 1c mov %i4, %o2
4000b540: 40 00 02 d5 call 4000c094 <rtems_rtl_elf_relocate_rela>
4000b544: 92 07 bf f4 add %fp, -12, %o1
4000b548: 80 a2 20 00 cmp %o0, 0
4000b54c: 12 bf ff e0 bne 4000b4cc <rtems_rtl_obj_relocate_unresolved+0x78>
<== ALWAYS TAKEN
4000b550: 82 10 00 08 mov %o0, %g1
}
4000b554: b0 08 60 ff and %g1, 0xff, %i0
<== NOT EXECUTED
4000b558: 81 c7 e0 08 ret
<== NOT EXECUTED
4000b55c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rtl_set_error (ENOEXEC, "unresolved sect not found");
4000b560: 90 10 20 08 mov 8, %o0
<== NOT EXECUTED
4000b564: 13 10 00 c2 sethi %hi(0x40030800), %o1
<== NOT EXECUTED
4000b568: 40 00 02 21 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000b56c: 92 12 60 78 or %o1, 0x78, %o1 ! 40030878 <tag_labels+0x23c>
<== NOT EXECUTED
return false;
4000b570: 82 10 20 00 clr %g1
<== NOT EXECUTED
}
4000b574: b0 08 60 ff and %g1, 0xff, %i0
<== NOT EXECUTED
4000b578: 81 c7 e0 08 ret
<== NOT EXECUTED
4000b57c: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtl: rel: sym:%d type:%d off:%08jx\n",
4000b580: d8 07 bf f4 ld [ %fp + -12 ], %o4
<== NOT EXECUTED
4000b584: 94 0a 60 ff and %o1, 0xff, %o2
<== NOT EXECUTED
4000b588: 96 10 20 00 clr %o3
<== NOT EXECUTED
4000b58c: 93 32 60 08 srl %o1, 8, %o1
<== NOT EXECUTED
4000b590: 11 10 00 c2 sethi %hi(0x40030800), %o0
<== NOT EXECUTED
4000b594: 40 00 34 ed call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000b598: 90 12 20 c8 or %o0, 0xc8, %o0 ! 400308c8 <tag_labels+0x28c>
<== NOT EXECUTED
if (!rtems_rtl_elf_relocate_rel (reloc->obj, &rel, sect,
4000b59c: 10 bf ff c3 b 4000b4a8 <rtems_rtl_obj_relocate_unresolved+0x54>
<== NOT EXECUTED
4000b5a0: d8 0e 60 13 ldub [ %i1 + 0x13 ], %o4
<== NOT EXECUTED
printf ("rtl: rela: sym:%d type:%d off:%08jx addend:%d\n",
4000b5a4: da 07 bf fc ld [ %fp + -4 ], %o5
<== NOT EXECUTED
4000b5a8: d8 07 bf f4 ld [ %fp + -12 ], %o4
<== NOT EXECUTED
4000b5ac: 94 0a 60 ff and %o1, 0xff, %o2
<== NOT EXECUTED
4000b5b0: 96 10 20 00 clr %o3
<== NOT EXECUTED
4000b5b4: 93 32 60 08 srl %o1, 8, %o1
<== NOT EXECUTED
4000b5b8: 11 10 00 c2 sethi %hi(0x40030800), %o0
<== NOT EXECUTED
4000b5bc: 40 00 34 e3 call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000b5c0: 90 12 20 98 or %o0, 0x98, %o0 ! 40030898 <tag_labels+0x25c>
<== NOT EXECUTED
if (!rtems_rtl_elf_relocate_rela (reloc->obj, &rela, sect,
4000b5c4: 10 bf ff db b 4000b530 <rtems_rtl_obj_relocate_unresolved+0xdc>
<== NOT EXECUTED
4000b5c8: d8 0e 60 13 ldub [ %i1 + 0x13 ], %o4
<== NOT EXECUTED
4000e738 <rtems_rtl_obj_synchronize_cache>:
{
4000e738: 9d e3 bf 90 save %sp, -112, %sp
if (rtems_cache_get_instruction_line_size() == 0)
4000e73c: 7f ff d8 b7 call 40004a18 <rtems_cache_get_instruction_line_size>
4000e740: 01 00 00 00 nop
4000e744: 80 a2 20 00 cmp %o0, 0
4000e748: 12 80 00 04 bne 4000e758 <rtems_rtl_obj_synchronize_cache+0x20>
<== ALWAYS TAKEN
4000e74c: 01 00 00 00 nop
}
4000e750: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e754: 81 e8 00 00 restore
<== NOT EXECUTED
sync_ctx.cache_line_size = rtems_cache_get_maximal_line_size();
4000e758: 7f ff d8 b2 call 40004a20 <rtems_cache_get_maximal_line_size>
4000e75c: 01 00 00 00 nop
sync_ctx.mask = RTEMS_RTL_OBJ_SECT_TEXT | RTEMS_RTL_OBJ_SECT_CONST |
4000e760: 03 00 00 04 sethi %hi(0x1000), %g1
4000e764: 82 10 60 1f or %g1, 0x1f, %g1 ! 101f <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0xecf>
sync_ctx.cache_line_size = rtems_cache_get_maximal_line_size();
4000e768: d0 27 bf fc st %o0, [ %fp + -4 ]
rtems_rtl_chain_iterate (&obj->sections,
4000e76c: 94 07 bf f0 add %fp, -16, %o2
sync_ctx.start_va = 0;
4000e770: c0 27 bf f4 clr [ %fp + -12 ]
rtems_rtl_chain_iterate (&obj->sections,
4000e774: 13 10 00 36 sethi %hi(0x4000d800), %o1
sync_ctx.end_va = sync_ctx.start_va;
4000e778: c0 27 bf f8 clr [ %fp + -8 ]
rtems_rtl_chain_iterate (&obj->sections,
4000e77c: 92 12 61 b8 or %o1, 0x1b8, %o1
sync_ctx.mask = RTEMS_RTL_OBJ_SECT_TEXT | RTEMS_RTL_OBJ_SECT_CONST |
4000e780: c2 27 bf f0 st %g1, [ %fp + -16 ]
rtems_rtl_chain_iterate (&obj->sections,
4000e784: 7f ff ef eb call 4000a730 <rtems_rtl_chain_iterate>
4000e788: 90 06 20 2c add %i0, 0x2c, %o0
if (sync_ctx.end_va != sync_ctx.start_va) {
4000e78c: d2 07 bf f8 ld [ %fp + -8 ], %o1
4000e790: d0 07 bf f4 ld [ %fp + -12 ], %o0
4000e794: 80 a2 40 08 cmp %o1, %o0
4000e798: 02 80 00 04 be 4000e7a8 <rtems_rtl_obj_synchronize_cache+0x70>
<== NEVER TAKEN
4000e79c: 01 00 00 00 nop
rtems_cache_instruction_sync_after_code_change(sync_ctx.start_va,
4000e7a0: 7f ff d8 a2 call 40004a28 <rtems_cache_instruction_sync_after_code_change>
4000e7a4: 92 22 40 08 sub %o1, %o0, %o1
}
4000e7a8: 81 c7 e0 08 ret
4000e7ac: 81 e8 00 00 restore
4000edb0 <rtems_rtl_obj_unload>:
bool
rtems_rtl_obj_unload (rtems_rtl_obj* obj)
{
4000edb0: 9d e3 bf a0 save %sp, -96, %sp
_rtld_linkmap_delete(obj);
4000edb4: 7f ff ee a1 call 4000a838 <_rtld_linkmap_delete>
4000edb8: 90 10 00 18 mov %i0, %o0
if (obj->format >= 0 && obj->format < RTEMS_RTL_LOADERS)
4000edbc: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
4000edc0: 80 a0 60 01 cmp %g1, 1
4000edc4: 18 80 00 08 bgu 4000ede4 <rtems_rtl_obj_unload+0x34>
<== NEVER TAKEN
4000edc8: 85 28 60 04 sll %g1, 4, %g2
return loaders[obj->format].unload (obj);
4000edcc: 03 10 00 c5 sethi %hi(0x40031400), %g1
4000edd0: 82 10 60 f0 or %g1, 0xf0, %g1 ! 400314f0 <loaders>
4000edd4: 82 00 40 02 add %g1, %g2, %g1
4000edd8: c2 00 60 08 ld [ %g1 + 8 ], %g1
4000eddc: 9f c0 40 00 call %g1
4000ede0: 90 10 00 18 mov %i0, %o0
rtems_rtl_obj_file_unload (obj);
return true;
}
4000ede4: 81 c7 e0 08 ret
4000ede8: 91 e8 20 01 restore %g0, 1, %o0
4000dc5c <rtems_rtl_parse_name>:
{
4000dc5c: 9d e3 bf a0 save %sp, -96, %sp
end = name + strlen (name);
4000dc60: 40 00 3b ff call 4001cc5c <strlen>
4000dc64: 90 10 00 18 mov %i0, %o0
colon = strrchr (name, ':');
4000dc68: 92 10 20 3a mov 0x3a, %o1
end = name + strlen (name);
4000dc6c: b8 10 00 08 mov %o0, %i4
colon = strrchr (name, ':');
4000dc70: 90 10 00 18 mov %i0, %o0
4000dc74: 40 00 3c b8 call 4001cf54 <strrchr>
4000dc78: a0 06 00 1c add %i0, %i4, %l0
if (colon == NULL || colon < strrchr(name, '/'))
4000dc7c: 80 a2 20 00 cmp %o0, 0
4000dc80: 02 80 00 32 be 4000dd48 <rtems_rtl_parse_name+0xec>
<== ALWAYS TAKEN
4000dc84: ba 10 00 08 mov %o0, %i5
4000dc88: 92 10 20 2f mov 0x2f, %o1
<== NOT EXECUTED
4000dc8c: 40 00 3c b2 call 4001cf54 <strrchr>
<== NOT EXECUTED
4000dc90: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000dc94: 80 a7 40 08 cmp %i5, %o0
<== NOT EXECUTED
4000dc98: 0a 80 00 2d bcs 4000dd4c <rtems_rtl_parse_name+0xf0>
<== NOT EXECUTED
4000dc9c: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
loname = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_OBJECT, colon - name + 1, true);
4000dca0: b8 27 40 18 sub %i5, %i0, %i4
<== NOT EXECUTED
4000dca4: 92 07 20 01 add %i4, 1, %o1
<== NOT EXECUTED
4000dca8: 7f ff f1 df call 4000a424 <rtems_rtl_alloc_new>
<== NOT EXECUTED
4000dcac: 90 10 20 00 clr %o0
<== NOT EXECUTED
if (!oname)
4000dcb0: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4000dcb4: 02 80 00 2c be 4000dd64 <rtems_rtl_parse_name+0x108>
<== NOT EXECUTED
4000dcb8: a4 10 00 08 mov %o0, %l2
<== NOT EXECUTED
memcpy ((void*) loname, name, colon - name);
4000dcbc: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
4000dcc0: 40 00 34 29 call 4001ad64 <memcpy>
<== NOT EXECUTED
4000dcc4: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
if (colon != end)
4000dcc8: 80 a4 00 1d cmp %l0, %i5
<== NOT EXECUTED
4000dccc: 02 80 00 44 be 4000dddc <rtems_rtl_parse_name+0x180>
<== NOT EXECUTED
4000dcd0: 92 10 20 40 mov 0x40, %o1
<== NOT EXECUTED
++colon;
4000dcd4: ba 07 60 01 inc %i5
<== NOT EXECUTED
at = strchr (colon, '@');
4000dcd8: 40 00 39 42 call 4001c1e0 <strchr>
<== NOT EXECUTED
4000dcdc: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
if (at == NULL)
4000dce0: b8 92 20 00 orcc %o0, 0, %i4
<== NOT EXECUTED
4000dce4: 02 80 00 2e be 4000dd9c <rtems_rtl_parse_name+0x140>
<== NOT EXECUTED
4000dce8: b0 27 00 1d sub %i4, %i5, %i0
<== NOT EXECUTED
loname = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_OBJECT, at - colon + 1, true);
4000dcec: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
4000dcf0: 92 06 20 01 add %i0, 1, %o1
<== NOT EXECUTED
4000dcf4: 7f ff f1 cc call 4000a424 <rtems_rtl_alloc_new>
<== NOT EXECUTED
4000dcf8: 90 10 20 00 clr %o0
<== NOT EXECUTED
if (!loname)
4000dcfc: a2 92 20 00 orcc %o0, 0, %l1
<== NOT EXECUTED
4000dd00: 02 80 00 32 be 4000ddc8 <rtems_rtl_parse_name+0x16c>
<== NOT EXECUTED
4000dd04: 94 10 00 18 mov %i0, %o2
<== NOT EXECUTED
memcpy ((void*) loname, colon, at - colon);
4000dd08: 40 00 34 17 call 4001ad64 <memcpy>
<== NOT EXECUTED
4000dd0c: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
if (at != end)
4000dd10: 80 a4 00 1c cmp %l0, %i4
<== NOT EXECUTED
4000dd14: 02 80 00 07 be 4000dd30 <rtems_rtl_parse_name+0xd4>
<== NOT EXECUTED
4000dd18: 94 10 20 00 clr %o2
<== NOT EXECUTED
*ooffset = strtoul (at + 1, 0, 0);
4000dd1c: 92 10 20 00 clr %o1
<== NOT EXECUTED
4000dd20: 40 00 3d 38 call 4001d200 <strtoul>
<== NOT EXECUTED
4000dd24: 90 07 20 01 add %i4, 1, %o0
<== NOT EXECUTED
4000dd28: c0 26 c0 00 clr [ %i3 ]
<== NOT EXECUTED
4000dd2c: d0 26 e0 04 st %o0, [ %i3 + 4 ]
<== NOT EXECUTED
return true;
4000dd30: b0 10 20 01 mov 1, %i0
<== NOT EXECUTED
*oname = loname;
4000dd34: e2 26 80 00 st %l1, [ %i2 ]
4000dd38: b0 0e 20 ff and %i0, 0xff, %i0
*aname = laname;
4000dd3c: e4 26 40 00 st %l2, [ %i1 ]
}
4000dd40: 81 c7 e0 08 ret
4000dd44: 81 e8 00 00 restore
loname = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_OBJECT, colon - name + 1, true);
4000dd48: 94 10 20 01 mov 1, %o2
4000dd4c: 92 07 20 01 add %i4, 1, %o1
4000dd50: 7f ff f1 b5 call 4000a424 <rtems_rtl_alloc_new>
4000dd54: 90 10 20 00 clr %o0
if (!oname)
4000dd58: 80 a6 a0 00 cmp %i2, 0
4000dd5c: 12 80 00 0a bne 4000dd84 <rtems_rtl_parse_name+0x128>
<== ALWAYS TAKEN
4000dd60: a2 10 00 08 mov %o0, %l1
rtems_rtl_set_error (ENOMEM, "no memory for object file name");
4000dd64: 90 10 20 0c mov 0xc, %o0
<== NOT EXECUTED
4000dd68: 13 10 00 c4 sethi %hi(0x40031000), %o1
<== NOT EXECUTED
return false;
4000dd6c: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (ENOMEM, "no memory for object file name");
4000dd70: 92 12 62 28 or %o1, 0x228, %o1
<== NOT EXECUTED
4000dd74: 7f ff f8 1e call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000dd78: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
}
4000dd7c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dd80: 81 e8 00 00 restore
<== NOT EXECUTED
memcpy ((void*) loname, name, colon - name);
4000dd84: 94 10 00 1c mov %i4, %o2
4000dd88: 92 10 00 18 mov %i0, %o1
4000dd8c: 40 00 33 f6 call 4001ad64 <memcpy>
4000dd90: a4 10 20 00 clr %l2
return true;
4000dd94: 10 bf ff e8 b 4000dd34 <rtems_rtl_parse_name+0xd8>
4000dd98: b0 10 20 01 mov 1, %i0
loname = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_OBJECT, at - colon + 1, true);
4000dd9c: a0 24 00 1d sub %l0, %i5, %l0
<== NOT EXECUTED
4000dda0: 94 10 20 01 mov 1, %o2
<== NOT EXECUTED
4000dda4: 7f ff f1 a0 call 4000a424 <rtems_rtl_alloc_new>
<== NOT EXECUTED
4000dda8: 92 04 20 01 add %l0, 1, %o1
<== NOT EXECUTED
if (!loname)
4000ddac: a2 92 20 00 orcc %o0, 0, %l1
<== NOT EXECUTED
4000ddb0: 02 80 00 06 be 4000ddc8 <rtems_rtl_parse_name+0x16c>
<== NOT EXECUTED
4000ddb4: 94 10 00 10 mov %l0, %o2
<== NOT EXECUTED
memcpy ((void*) loname, colon, at - colon);
4000ddb8: 40 00 33 eb call 4001ad64 <memcpy>
<== NOT EXECUTED
4000ddbc: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
return true;
4000ddc0: 10 bf ff dd b 4000dd34 <rtems_rtl_parse_name+0xd8>
<== NOT EXECUTED
4000ddc4: b0 10 20 01 mov 1, %i0
<== NOT EXECUTED
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_OBJECT, (void*) laname);
4000ddc8: 92 10 00 12 mov %l2, %o1
<== NOT EXECUTED
4000ddcc: 7f ff f1 bf call 4000a4c8 <rtems_rtl_alloc_del>
<== NOT EXECUTED
4000ddd0: 90 10 20 00 clr %o0
<== NOT EXECUTED
rtems_rtl_set_error (ENOMEM, "no memory for object file name");
4000ddd4: 10 bf ff e5 b 4000dd68 <rtems_rtl_parse_name+0x10c>
<== NOT EXECUTED
4000ddd8: 90 10 20 0c mov 0xc, %o0
<== NOT EXECUTED
4000dddc: a2 10 00 12 mov %l2, %l1
<== NOT EXECUTED
const char* laname = NULL;
4000dde0: 10 bf ff d4 b 4000dd30 <rtems_rtl_parse_name+0xd4>
<== NOT EXECUTED
4000dde4: a4 10 20 00 clr %l2
<== NOT EXECUTED
4000efc8 <rtems_rtl_rap_file_check>:
bool
rtems_rtl_rap_file_check (rtems_rtl_obj* obj, int fd)
{
4000efc8: 9d e3 bf 80 save %sp, -128, %sp
rtems_rtl_obj_cache* header;
uint8_t* rhdr = NULL;
size_t rlen = 64;
4000efcc: 82 10 20 40 mov 0x40, %g1
uint32_t length = 0;
uint32_t version = 0;
uint32_t compression = 0;
uint32_t checksum = 0;
rtems_rtl_obj_caches (&header, NULL, NULL);
4000efd0: 94 10 20 00 clr %o2
4000efd4: 92 10 20 00 clr %o1
4000efd8: 90 07 bf e4 add %fp, -28, %o0
size_t rlen = 64;
4000efdc: c2 27 bf ec st %g1, [ %fp + -20 ]
uint8_t* rhdr = NULL;
4000efe0: c0 27 bf e8 clr [ %fp + -24 ]
uint32_t length = 0;
4000efe4: c0 27 bf f0 clr [ %fp + -16 ]
uint32_t version = 0;
4000efe8: c0 27 bf f4 clr [ %fp + -12 ]
uint32_t compression = 0;
4000efec: c0 27 bf f8 clr [ %fp + -8 ]
rtems_rtl_obj_caches (&header, NULL, NULL);
4000eff0: 7f ff f4 d9 call 4000c354 <rtems_rtl_obj_caches>
4000eff4: c0 27 bf fc clr [ %fp + -4 ]
if (!rtems_rtl_obj_cache_read (header, fd, obj->ooffset,
4000eff8: d4 1e 20 20 ldd [ %i0 + 0x20 ], %o2
4000effc: d0 07 bf e4 ld [ %fp + -28 ], %o0
4000f000: 9a 07 bf ec add %fp, -20, %o5
4000f004: 98 07 bf e8 add %fp, -24, %o4
4000f008: 7f ff f7 57 call 4000cd64 <rtems_rtl_obj_cache_read>
4000f00c: 92 10 00 19 mov %i1, %o1
4000f010: 80 a2 20 00 cmp %o0, 0
4000f014: 32 80 00 06 bne,a 4000f02c <rtems_rtl_rap_file_check+0x64>
<== ALWAYS TAKEN
4000f018: c0 27 bf ec clr [ %fp + -20 ]
(void**) &rhdr, &rlen))
return false;
4000f01c: b0 10 20 00 clr %i0
<== NOT EXECUTED
&compression,
&checksum))
return false;
return true;
}
4000f020: b0 0e 20 ff and %i0, 0xff, %i0
4000f024: 81 c7 e0 08 ret
4000f028: 81 e8 00 00 restore
if (!rtems_rtl_rap_parse_header (rhdr,
4000f02c: d0 07 bf e8 ld [ %fp + -24 ], %o0
if ((rhdr[0] != 'R') || (rhdr[1] != 'A') || (rhdr[2] != 'P') || (rhdr[3] != ','))
4000f030: c2 0a 00 00 ldub [ %o0 ], %g1
4000f034: 80 a0 60 52 cmp %g1, 0x52
4000f038: 12 bf ff fa bne 4000f020 <rtems_rtl_rap_file_check+0x58>
4000f03c: b0 10 20 00 clr %i0
4000f040: c2 0a 20 01 ldub [ %o0 + 1 ], %g1
4000f044: 80 a0 60 41 cmp %g1, 0x41
4000f048: 12 bf ff f7 bne 4000f024 <rtems_rtl_rap_file_check+0x5c>
<== NEVER TAKEN
4000f04c: b0 0e 20 ff and %i0, 0xff, %i0
4000f050: c2 0a 20 02 ldub [ %o0 + 2 ], %g1
4000f054: 80 a0 60 50 cmp %g1, 0x50
4000f058: 32 bf ff f2 bne,a 4000f020 <rtems_rtl_rap_file_check+0x58>
<== NEVER TAKEN
4000f05c: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000f060: c2 0a 20 03 ldub [ %o0 + 3 ], %g1
4000f064: 80 a0 60 2c cmp %g1, 0x2c
4000f068: 32 bf ff ee bne,a 4000f020 <rtems_rtl_rap_file_check+0x58>
<== NEVER TAKEN
4000f06c: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000f070: 9a 07 bf fc add %fp, -4, %o5
4000f074: 98 07 bf f8 add %fp, -8, %o4
4000f078: 96 07 bf f4 add %fp, -12, %o3
4000f07c: 94 07 bf f0 add %fp, -16, %o2
4000f080: 7f ff ff 81 call 4000ee84 <rtems_rtl_rap_parse_header.part.2>
4000f084: 92 07 bf ec add %fp, -20, %o1
4000f088: 10 bf ff e6 b 4000f020 <rtems_rtl_rap_file_check+0x58>
4000f08c: b0 10 00 08 mov %o0, %i0
4000f090 <rtems_rtl_rap_file_load>:
bool
rtems_rtl_rap_file_load (rtems_rtl_obj* obj, int fd)
{
4000f090: 9d e3 be d8 save %sp, -296, %sp
rtems_rtl_rap rap = { 0 };
4000f094: 94 10 20 7c mov 0x7c, %o2
4000f098: 92 10 20 00 clr %o1
4000f09c: 40 00 2f bc call 4001af8c <memset>
4000f0a0: 90 07 bf 84 add %fp, -124, %o0
uint8_t* rhdr = NULL;
size_t rlen = 64;
4000f0a4: 82 10 20 40 mov 0x40, %g1
int section;
rtems_rtl_obj_caches (&rap.file, NULL, NULL);
4000f0a8: 94 10 20 00 clr %o2
4000f0ac: 92 10 20 00 clr %o1
4000f0b0: 90 07 bf 84 add %fp, -124, %o0
size_t rlen = 64;
4000f0b4: c2 27 bf 64 st %g1, [ %fp + -156 ]
rtems_rtl_obj_caches (&rap.file, NULL, NULL);
4000f0b8: 7f ff f4 a7 call 4000c354 <rtems_rtl_obj_caches>
4000f0bc: c0 27 bf 60 clr [ %fp + -160 ]
if (!rtems_rtl_obj_cache_read (rap.file, fd, obj->ooffset,
4000f0c0: d0 07 bf 84 ld [ %fp + -124 ], %o0
4000f0c4: d4 1e 20 20 ldd [ %i0 + 0x20 ], %o2
4000f0c8: 98 07 bf 60 add %fp, -160, %o4
4000f0cc: 9a 07 bf 64 add %fp, -156, %o5
4000f0d0: 7f ff f7 25 call 4000cd64 <rtems_rtl_obj_cache_read>
4000f0d4: 92 10 00 19 mov %i1, %o1
4000f0d8: 80 a2 20 00 cmp %o0, 0
4000f0dc: 32 80 00 06 bne,a 4000f0f4 <rtems_rtl_rap_file_load+0x64>
<== ALWAYS TAKEN
4000f0e0: c0 27 bf 64 clr [ %fp + -156 ]
if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD))
printf ("rtl: rap: input relocs=%" PRIu32 "\n",
rtems_rtl_obj_comp_input (rap.decomp));
if (!rtems_rtl_rap_relocate (&rap, obj))
return false;
4000f0e4: ae 10 20 00 clr %l7
<== NOT EXECUTED
rtems_rtl_obj_synchronize_cache (obj);
return true;
}
4000f0e8: b0 0d e0 ff and %l7, 0xff, %i0
<== NOT EXECUTED
4000f0ec: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f0f0: 81 e8 00 00 restore
<== NOT EXECUTED
if (!rtems_rtl_rap_parse_header (rhdr,
4000f0f4: d0 07 bf 60 ld [ %fp + -160 ], %o0
if ((rhdr[0] != 'R') || (rhdr[1] != 'A') || (rhdr[2] != 'P') || (rhdr[3] != ','))
4000f0f8: c2 0a 00 00 ldub [ %o0 ], %g1
4000f0fc: 80 a0 60 52 cmp %g1, 0x52
4000f100: 22 80 00 0a be,a 4000f128 <rtems_rtl_rap_file_load+0x98>
<== ALWAYS TAKEN
4000f104: c2 0a 20 01 ldub [ %o0 + 1 ], %g1
rtems_rtl_set_error (EINVAL, "invalid RAP file format");
4000f108: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
return false;
4000f10c: ae 10 20 00 clr %l7
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "invalid RAP file format");
4000f110: 13 10 00 c5 sethi %hi(0x40031400), %o1
<== NOT EXECUTED
}
4000f114: b0 0d e0 ff and %l7, 0xff, %i0
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "invalid RAP file format");
4000f118: 7f ff f3 35 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000f11c: 92 12 61 38 or %o1, 0x138, %o1
<== NOT EXECUTED
}
4000f120: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f124: 81 e8 00 00 restore
<== NOT EXECUTED
if ((rhdr[0] != 'R') || (rhdr[1] != 'A') || (rhdr[2] != 'P') || (rhdr[3] != ','))
4000f128: 80 a0 60 41 cmp %g1, 0x41
4000f12c: 32 bf ff f8 bne,a 4000f10c <rtems_rtl_rap_file_load+0x7c>
<== NEVER TAKEN
4000f130: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
4000f134: c2 0a 20 02 ldub [ %o0 + 2 ], %g1
4000f138: 80 a0 60 50 cmp %g1, 0x50
4000f13c: 32 bf ff f4 bne,a 4000f10c <rtems_rtl_rap_file_load+0x7c>
<== NEVER TAKEN
4000f140: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
4000f144: c2 0a 20 03 ldub [ %o0 + 3 ], %g1
4000f148: 80 a0 60 2c cmp %g1, 0x2c
4000f14c: 32 bf ff f0 bne,a 4000f10c <rtems_rtl_rap_file_load+0x7c>
<== NEVER TAKEN
4000f150: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
4000f154: 9a 07 bf 98 add %fp, -104, %o5
4000f158: 98 07 bf 94 add %fp, -108, %o4
4000f15c: 96 07 bf 90 add %fp, -112, %o3
4000f160: 94 07 bf 8c add %fp, -116, %o2
4000f164: 7f ff ff 48 call 4000ee84 <rtems_rtl_rap_parse_header.part.2>
4000f168: 92 07 bf 64 add %fp, -156, %o1
if (!rtems_rtl_rap_parse_header (rhdr,
4000f16c: 80 a2 20 00 cmp %o0, 0
4000f170: 02 bf ff e6 be 4000f108 <rtems_rtl_rap_file_load+0x78>
<== NEVER TAKEN
4000f174: d8 07 bf 64 ld [ %fp + -156 ], %o4
rtems_rtl_obj_decompress (&rap.decomp, rap.file, fd, rap.compression,
4000f178: c4 1e 20 20 ldd [ %i0 + 0x20 ], %g2
4000f17c: ba 80 c0 0c addcc %g3, %o4, %i5
4000f180: d6 07 bf 94 ld [ %fp + -108 ], %o3
4000f184: d2 07 bf 84 ld [ %fp + -124 ], %o1
4000f188: b8 40 a0 00 addx %g2, 0, %i4
4000f18c: 9a 10 00 1d mov %i5, %o5
4000f190: 98 10 00 1c mov %i4, %o4
4000f194: 94 10 00 19 mov %i1, %o2
4000f198: 7f ff f4 9b call 4000c404 <rtems_rtl_obj_decompress>
4000f19c: 90 07 bf 88 add %fp, -120, %o0
if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD))
4000f1a0: 40 00 05 19 call 40010604 <rtems_rtl_trace>
4000f1a4: 90 10 20 04 mov 4, %o0
4000f1a8: 80 a2 20 00 cmp %o0, 0
4000f1ac: 12 80 00 1a bne 4000f214 <rtems_rtl_rap_file_load+0x184>
<== NEVER TAKEN
4000f1b0: c2 07 bf 88 ld [ %fp + -120 ], %g1
if (!rtems_rtl_rap_read_uint32 (rap.decomp, &rap.machinetype))
4000f1b4: d0 07 bf 88 ld [ %fp + -120 ], %o0
4000f1b8: 7f ff ff 1f call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f1bc: 92 07 bf 9c add %fp, -100, %o1
4000f1c0: 80 a2 20 00 cmp %o0, 0
4000f1c4: 02 bf ff c9 be 4000f0e8 <rtems_rtl_rap_file_load+0x58>
<== NEVER TAKEN
4000f1c8: ae 10 20 00 clr %l7
if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD))
4000f1cc: 40 00 05 0e call 40010604 <rtems_rtl_trace>
4000f1d0: 90 10 20 04 mov 4, %o0
4000f1d4: 80 a2 20 00 cmp %o0, 0
4000f1d8: 12 80 00 2b bne 4000f284 <rtems_rtl_rap_file_load+0x1f4>
<== NEVER TAKEN
4000f1dc: d2 07 bf 9c ld [ %fp + -100 ], %o1
switch (machinetype)
4000f1e0: c2 07 bf 9c ld [ %fp + -100 ], %g1
4000f1e4: 80 a0 60 02 cmp %g1, 2
4000f1e8: 02 80 00 11 be 4000f22c <rtems_rtl_rap_file_load+0x19c>
<== ALWAYS TAKEN
4000f1ec: 80 a0 60 12 cmp %g1, 0x12
4000f1f0: 02 80 00 0f be 4000f22c <rtems_rtl_rap_file_load+0x19c>
<== NOT EXECUTED
4000f1f4: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "invalid machinetype");
4000f1f8: 13 10 00 c5 sethi %hi(0x40031400), %o1
<== NOT EXECUTED
return false;
4000f1fc: ae 10 20 00 clr %l7
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "invalid machinetype");
4000f200: 7f ff f2 fb call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000f204: 92 12 61 90 or %o1, 0x190, %o1
<== NOT EXECUTED
4000f208: b0 0d e0 ff and %l7, 0xff, %i0
<== NOT EXECUTED
4000f20c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f210: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtl: rap: input machine=%" PRIu32 "\n",
4000f214: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
<== NOT EXECUTED
4000f218: 11 10 00 c5 sethi %hi(0x40031400), %o0
<== NOT EXECUTED
4000f21c: 40 00 25 cb call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000f220: 90 12 21 50 or %o0, 0x150, %o0 ! 40031550 <loaders+0x60>
<== NOT EXECUTED
if (!rtems_rtl_rap_read_uint32 (rap.decomp, &rap.machinetype))
4000f224: 10 bf ff e5 b 4000f1b8 <rtems_rtl_rap_file_load+0x128>
<== NOT EXECUTED
4000f228: d0 07 bf 88 ld [ %fp + -120 ], %o0
<== NOT EXECUTED
if (!rtems_rtl_rap_read_uint32 (rap.decomp, &rap.datatype))
4000f22c: d0 07 bf 88 ld [ %fp + -120 ], %o0
4000f230: 7f ff ff 01 call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f234: 92 07 bf a0 add %fp, -96, %o1
4000f238: 80 a2 20 00 cmp %o0, 0
4000f23c: 02 bf ff ab be 4000f0e8 <rtems_rtl_rap_file_load+0x58>
<== NEVER TAKEN
4000f240: ae 10 20 00 clr %l7
if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD))
4000f244: 40 00 04 f0 call 40010604 <rtems_rtl_trace>
4000f248: 90 10 20 04 mov 4, %o0
4000f24c: 80 a2 20 00 cmp %o0, 0
4000f250: 12 80 01 1d bne 4000f6c4 <rtems_rtl_rap_file_load+0x634>
<== NEVER TAKEN
4000f254: d2 07 bf a0 ld [ %fp + -96 ], %o1
if (datatype != ELFDEFNNAME (MACHDEP_ENDIANNESS))
4000f258: c2 07 bf a0 ld [ %fp + -96 ], %g1
4000f25c: 80 a0 60 02 cmp %g1, 2
4000f260: 02 80 00 0e be 4000f298 <rtems_rtl_rap_file_load+0x208>
<== ALWAYS TAKEN
4000f264: 90 10 20 16 mov 0x16, %o0
rtems_rtl_set_error (EINVAL, "invalid datatype");
4000f268: 13 10 00 c5 sethi %hi(0x40031400), %o1
<== NOT EXECUTED
return false;
4000f26c: ae 10 20 00 clr %l7
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "invalid datatype");
4000f270: 7f ff f2 df call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000f274: 92 12 61 c0 or %o1, 0x1c0, %o1
<== NOT EXECUTED
4000f278: b0 0d e0 ff and %l7, 0xff, %i0
<== NOT EXECUTED
4000f27c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f280: 81 e8 00 00 restore
<== NOT EXECUTED
printf ("rtl: rap: machinetype=%" PRIu32 "\n", rap.machinetype);
4000f284: 11 10 00 c5 sethi %hi(0x40031400), %o0
<== NOT EXECUTED
4000f288: 40 00 25 b0 call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000f28c: 90 12 21 70 or %o0, 0x170, %o0 ! 40031570 <loaders+0x80>
<== NOT EXECUTED
switch (machinetype)
4000f290: 10 bf ff d5 b 4000f1e4 <rtems_rtl_rap_file_load+0x154>
<== NOT EXECUTED
4000f294: c2 07 bf 9c ld [ %fp + -100 ], %g1
<== NOT EXECUTED
if (!rtems_rtl_rap_read_uint32 (rap.decomp, &rap.class))
4000f298: d0 07 bf 88 ld [ %fp + -120 ], %o0
4000f29c: 7f ff fe e6 call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f2a0: 92 07 bf a4 add %fp, -92, %o1
4000f2a4: 80 a2 20 00 cmp %o0, 0
4000f2a8: 02 bf ff 90 be 4000f0e8 <rtems_rtl_rap_file_load+0x58>
<== NEVER TAKEN
4000f2ac: ae 10 20 00 clr %l7
if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD))
4000f2b0: 40 00 04 d5 call 40010604 <rtems_rtl_trace>
4000f2b4: 90 10 20 04 mov 4, %o0
4000f2b8: 80 a2 20 00 cmp %o0, 0
4000f2bc: 02 80 00 07 be 4000f2d8 <rtems_rtl_rap_file_load+0x248>
<== ALWAYS TAKEN
4000f2c0: c2 07 bf a4 ld [ %fp + -92 ], %g1
printf ("rtl: rap: class=%" PRIu32 "\n", rap.class);
4000f2c4: d2 07 bf a4 ld [ %fp + -92 ], %o1
<== NOT EXECUTED
4000f2c8: 11 10 00 c5 sethi %hi(0x40031400), %o0
<== NOT EXECUTED
4000f2cc: 40 00 25 9f call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000f2d0: 90 12 21 d8 or %o0, 0x1d8, %o0 ! 400315d8 <loaders+0xe8>
<== NOT EXECUTED
switch (class)
4000f2d4: c2 07 bf a4 ld [ %fp + -92 ], %g1
<== NOT EXECUTED
4000f2d8: 80 a0 60 01 cmp %g1, 1
4000f2dc: 12 80 00 ff bne 4000f6d8 <rtems_rtl_rap_file_load+0x648>
<== NEVER TAKEN
4000f2e0: 90 10 20 16 mov 0x16, %o0
if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD))
4000f2e4: 40 00 04 c8 call 40010604 <rtems_rtl_trace>
4000f2e8: 90 10 20 04 mov 4, %o0
4000f2ec: 80 a2 20 00 cmp %o0, 0
4000f2f0: 22 80 00 08 be,a 4000f310 <rtems_rtl_rap_file_load+0x280>
<== ALWAYS TAKEN
4000f2f4: d0 07 bf 88 ld [ %fp + -120 ], %o0
printf ("rtl: rap: input header=%" PRIu32 "\n",
4000f2f8: c2 07 bf 88 ld [ %fp + -120 ], %g1
<== NOT EXECUTED
4000f2fc: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
<== NOT EXECUTED
4000f300: 11 10 00 c5 sethi %hi(0x40031400), %o0
<== NOT EXECUTED
4000f304: 40 00 25 91 call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000f308: 90 12 22 00 or %o0, 0x200, %o0 ! 40031600 <loaders+0x110>
<== NOT EXECUTED
if (!rtems_rtl_rap_read_uint32 (rap.decomp, &rap.init))
4000f30c: d0 07 bf 88 ld [ %fp + -120 ], %o0
<== NOT EXECUTED
4000f310: 7f ff fe c9 call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f314: 92 07 bf a8 add %fp, -88, %o1
4000f318: 80 a2 20 00 cmp %o0, 0
4000f31c: 02 bf ff 73 be 4000f0e8 <rtems_rtl_rap_file_load+0x58>
<== NEVER TAKEN
4000f320: ae 10 20 00 clr %l7
if (!rtems_rtl_rap_read_uint32 (rap.decomp, &rap.fini))
4000f324: d0 07 bf 88 ld [ %fp + -120 ], %o0
4000f328: 7f ff fe c3 call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f32c: 92 07 bf ac add %fp, -84, %o1
4000f330: 80 a2 20 00 cmp %o0, 0
4000f334: 02 bf ff 6d be 4000f0e8 <rtems_rtl_rap_file_load+0x58>
<== NEVER TAKEN
4000f338: ae 10 20 00 clr %l7
if (!rtems_rtl_rap_read_uint32 (rap.decomp, &rap.symtab_size))
4000f33c: d0 07 bf 88 ld [ %fp + -120 ], %o0
4000f340: 7f ff fe bd call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f344: 92 07 bf e0 add %fp, -32, %o1
4000f348: 80 a2 20 00 cmp %o0, 0
4000f34c: 02 bf ff 67 be 4000f0e8 <rtems_rtl_rap_file_load+0x58>
<== NEVER TAKEN
4000f350: ae 10 20 00 clr %l7
if (!rtems_rtl_rap_read_uint32 (rap.decomp, &rap.strtab_size))
4000f354: d0 07 bf 88 ld [ %fp + -120 ], %o0
4000f358: 7f ff fe b7 call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f35c: 92 07 bf e8 add %fp, -24, %o1
4000f360: 80 a2 20 00 cmp %o0, 0
4000f364: 02 bf ff 61 be 4000f0e8 <rtems_rtl_rap_file_load+0x58>
<== NEVER TAKEN
4000f368: ae 10 20 00 clr %l7
if (!rtems_rtl_rap_read_uint32 (rap.decomp, &rap.relocs_size))
4000f36c: d0 07 bf 88 ld [ %fp + -120 ], %o0
4000f370: 7f ff fe b1 call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f374: 92 07 bf ec add %fp, -20, %o1
4000f378: 80 a2 20 00 cmp %o0, 0
4000f37c: 02 bf ff 5b be 4000f0e8 <rtems_rtl_rap_file_load+0x58>
<== NEVER TAKEN
4000f380: ae 10 20 00 clr %l7
rap.symbols = rap.symtab_size / (3 * sizeof (uint32_t));
4000f384: c2 07 bf e0 ld [ %fp + -32 ], %g1
4000f388: 05 2a aa aa sethi %hi(0xaaaaa800), %g2
4000f38c: 84 10 a2 ab or %g2, 0x2ab, %g2 ! aaaaaaab <RAM_END+0x6a6aaaab>
4000f390: 80 50 40 02 umul %g1, %g2, %g0
4000f394: 83 40 00 00 rd %y, %g1
4000f398: 83 30 60 03 srl %g1, 3, %g1
if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD))
4000f39c: 90 10 20 04 mov 4, %o0
4000f3a0: 40 00 04 99 call 40010604 <rtems_rtl_trace>
4000f3a4: c2 27 bf f0 st %g1, [ %fp + -16 ]
4000f3a8: 80 a2 20 00 cmp %o0, 0
4000f3ac: 22 80 00 0a be,a 4000f3d4 <rtems_rtl_rap_file_load+0x344>
<== ALWAYS TAKEN
4000f3b0: d0 07 bf 88 ld [ %fp + -120 ], %o0
printf ("rtl: rap: load: symtab=%" PRIu32 " (%" PRIu32
4000f3b4: d8 07 bf ec ld [ %fp + -20 ], %o4
<== NOT EXECUTED
4000f3b8: d6 07 bf e8 ld [ %fp + -24 ], %o3
<== NOT EXECUTED
4000f3bc: d4 07 bf f0 ld [ %fp + -16 ], %o2
<== NOT EXECUTED
4000f3c0: d2 07 bf e0 ld [ %fp + -32 ], %o1
<== NOT EXECUTED
4000f3c4: 11 10 00 c5 sethi %hi(0x40031400), %o0
<== NOT EXECUTED
4000f3c8: 40 00 25 60 call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000f3cc: 90 12 22 20 or %o0, 0x220, %o0 ! 40031620 <loaders+0x130>
<== NOT EXECUTED
if (!rtems_rtl_rap_read_uint32 (rap.decomp, &obj->obj_num))
4000f3d0: d0 07 bf 88 ld [ %fp + -120 ], %o0
<== NOT EXECUTED
4000f3d4: 7f ff fe 98 call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f3d8: 92 06 20 84 add %i0, 0x84, %o1
4000f3dc: 80 a2 20 00 cmp %o0, 0
4000f3e0: 02 bf ff 42 be 4000f0e8 <rtems_rtl_rap_file_load+0x58>
<== NEVER TAKEN
4000f3e4: ae 10 20 00 clr %l7
if (obj->obj_num > 0)
4000f3e8: d0 06 20 84 ld [ %i0 + 0x84 ], %o0
4000f3ec: 80 a2 20 00 cmp %o0, 0
4000f3f0: 12 80 00 c1 bne 4000f6f4 <rtems_rtl_rap_file_load+0x664>
<== ALWAYS TAKEN
4000f3f4: fa 07 bf 88 ld [ %fp + -120 ], %i5
4000f3f8: 23 10 00 c6 sethi %hi(0x40031800), %l1
printf ("rtl: rap: %s: size=%" PRIu32 " align=%" PRIu32 "\n",
4000f3fc: 35 10 00 c5 sethi %hi(0x40031400), %i2
4000f400: a2 14 61 7c or %l1, 0x17c, %l1
4000f404: ba 07 bf b0 add %fp, -80, %i5
4000f408: b6 10 00 11 mov %l1, %i3
for (i = 0; i < obj->obj_num; ++i)
4000f40c: b8 10 20 00 clr %i4
printf ("rtl: rap: %s: size=%" PRIu32 " align=%" PRIu32 "\n",
4000f410: b4 16 a2 f0 or %i2, 0x2f0, %i2
if (!rtems_rtl_rap_read_uint32 (rap.decomp, &rap.secs[section].size))
4000f414: d0 07 bf 88 ld [ %fp + -120 ], %o0
4000f418: 7f ff fe 87 call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f41c: 92 10 00 1d mov %i5, %o1
4000f420: 80 a2 20 00 cmp %o0, 0
4000f424: 02 bf ff 30 be 4000f0e4 <rtems_rtl_rap_file_load+0x54>
<== NEVER TAKEN
4000f428: d0 07 bf 88 ld [ %fp + -120 ], %o0
if (!rtems_rtl_rap_read_uint32 (rap.decomp, &rap.secs[section].alignment))
4000f42c: 7f ff fe 82 call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f430: 92 07 60 04 add %i5, 4, %o1
4000f434: 80 a2 20 00 cmp %o0, 0
4000f438: 02 bf ff 2c be 4000f0e8 <rtems_rtl_rap_file_load+0x58>
<== NEVER TAKEN
4000f43c: ae 10 20 00 clr %l7
if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD_SECT))
4000f440: 40 00 04 71 call 40010604 <rtems_rtl_trace>
4000f444: 90 10 21 00 mov 0x100, %o0
4000f448: 80 a2 20 00 cmp %o0, 0
4000f44c: 02 80 00 07 be 4000f468 <rtems_rtl_rap_file_load+0x3d8>
<== ALWAYS TAKEN
4000f450: e0 06 c0 00 ld [ %i3 ], %l0
printf ("rtl: rap: %s: size=%" PRIu32 " align=%" PRIu32 "\n",
4000f454: d6 07 60 04 ld [ %i5 + 4 ], %o3
<== NOT EXECUTED
4000f458: d4 07 40 00 ld [ %i5 ], %o2
<== NOT EXECUTED
4000f45c: 92 10 00 10 mov %l0, %o1
<== NOT EXECUTED
4000f460: 40 00 25 3a call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000f464: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
if (!rtems_rtl_obj_add_section (obj,
4000f468: c4 06 e0 04 ld [ %i3 + 4 ], %g2
4000f46c: c2 07 60 04 ld [ %i5 + 4 ], %g1
4000f470: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4000f474: 92 10 00 1c mov %i4, %o1
4000f478: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
4000f47c: 98 10 20 00 clr %o4
4000f480: c0 23 a0 64 clr [ %sp + 0x64 ]
4000f484: 9a 10 20 00 clr %o5
4000f488: c0 23 a0 60 clr [ %sp + 0x60 ]
4000f48c: 94 10 00 10 mov %l0, %o2
4000f490: d6 07 40 00 ld [ %i5 ], %o3
4000f494: 7f ff fc 42 call 4000e59c <rtems_rtl_obj_add_section>
4000f498: 90 10 00 18 mov %i0, %o0
4000f49c: 80 a2 20 00 cmp %o0, 0
4000f4a0: 02 bf ff 11 be 4000f0e4 <rtems_rtl_rap_file_load+0x54>
<== NEVER TAKEN
4000f4a4: b8 07 20 01 inc %i4
4000f4a8: ba 07 60 08 add %i5, 8, %i5
for (section = 0; section < RTEMS_RTL_RAP_SECS; ++section)
4000f4ac: 80 a7 20 06 cmp %i4, 6
4000f4b0: 12 bf ff d9 bne 4000f414 <rtems_rtl_rap_file_load+0x384>
4000f4b4: b6 06 e0 08 add %i3, 8, %i3
if (!rtems_rtl_obj_load_sections (obj, fd, rtems_rtl_rap_loader, &rap))
4000f4b8: 96 07 bf 84 add %fp, -124, %o3
4000f4bc: 92 10 00 19 mov %i1, %o1
4000f4c0: 15 10 00 3b sethi %hi(0x4000ec00), %o2
4000f4c4: 90 10 00 18 mov %i0, %o0
4000f4c8: 7f ff fc d4 call 4000e818 <rtems_rtl_obj_load_sections>
4000f4cc: 94 12 a1 ec or %o2, 0x1ec, %o2
4000f4d0: 80 a2 20 00 cmp %o0, 0
4000f4d4: 02 bf ff 05 be 4000f0e8 <rtems_rtl_rap_file_load+0x58>
<== NEVER TAKEN
4000f4d8: ae 10 20 00 clr %l7
if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD))
4000f4dc: 40 00 04 4a call 40010604 <rtems_rtl_trace>
4000f4e0: 90 10 20 04 mov 4, %o0
4000f4e4: 80 a2 20 00 cmp %o0, 0
4000f4e8: 22 80 00 08 be,a 4000f508 <rtems_rtl_rap_file_load+0x478>
<== ALWAYS TAKEN
4000f4ec: c2 07 bf f0 ld [ %fp + -16 ], %g1
printf ("rtl: rap: input symbols=%" PRIu32 "\n",
4000f4f0: c2 07 bf 88 ld [ %fp + -120 ], %g1
<== NOT EXECUTED
4000f4f4: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
<== NOT EXECUTED
4000f4f8: 11 10 00 c5 sethi %hi(0x40031400), %o0
<== NOT EXECUTED
4000f4fc: 40 00 25 13 call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000f500: 90 12 23 18 or %o0, 0x318, %o0 ! 40031718 <loaders+0x228>
<== NOT EXECUTED
rap->symbols * sizeof (rtems_rtl_obj_sym) + rap->strtab_size;
4000f504: c2 07 bf f0 ld [ %fp + -16 ], %g1
<== NOT EXECUTED
4000f508: 93 28 60 02 sll %g1, 2, %o1
4000f50c: 92 02 40 01 add %o1, %g1, %o1
4000f510: c2 07 bf e8 ld [ %fp + -24 ], %g1
4000f514: 93 2a 60 02 sll %o1, 2, %o1
4000f518: 92 02 40 01 add %o1, %g1, %o1
obj->global_size =
4000f51c: d2 26 20 4c st %o1, [ %i0 + 0x4c ]
obj->global_table = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_SYMBOL,
4000f520: 94 10 20 01 mov 1, %o2
4000f524: 7f ff eb c0 call 4000a424 <rtems_rtl_alloc_new>
4000f528: 90 10 20 01 mov 1, %o0
4000f52c: d0 26 20 44 st %o0, [ %i0 + 0x44 ]
if (!obj->global_table)
4000f530: 80 a2 20 00 cmp %o0, 0
4000f534: 02 80 00 f3 be 4000f900 <rtems_rtl_rap_file_load+0x870>
<== NEVER TAKEN
4000f538: 82 10 00 08 mov %o0, %g1
obj->global_syms = rap->symbols;
4000f53c: c4 07 bf f0 ld [ %fp + -16 ], %g2
4000f540: c4 26 20 48 st %g2, [ %i0 + 0x48 ]
(rap->symbols * sizeof (rtems_rtl_obj_sym)));
4000f544: 93 28 a0 02 sll %g2, 2, %o1
if (!rtems_rtl_obj_comp_read (rap->decomp, rap->strtab, rap->strtab_size))
4000f548: d4 07 bf e8 ld [ %fp + -24 ], %o2
4000f54c: d0 07 bf 88 ld [ %fp + -120 ], %o0
(rap->symbols * sizeof (rtems_rtl_obj_sym)));
4000f550: 92 02 40 02 add %o1, %g2, %o1
4000f554: 93 2a 60 02 sll %o1, 2, %o1
rap->strtab = (((char*) obj->global_table) +
4000f558: 92 00 40 09 add %g1, %o1, %o1
if (!rtems_rtl_obj_comp_read (rap->decomp, rap->strtab, rap->strtab_size))
4000f55c: 7f ff f7 88 call 4000d37c <rtems_rtl_obj_comp_read>
4000f560: d2 27 bf e4 st %o1, [ %fp + -28 ]
4000f564: 80 a2 20 00 cmp %o0, 0
4000f568: 02 80 00 e0 be 4000f8e8 <rtems_rtl_rap_file_load+0x858>
<== NEVER TAKEN
4000f56c: ae 10 00 08 mov %o0, %l7
for (sym = 0, gsym = obj->global_table; sym < rap->symbols; ++sym)
4000f570: fa 06 20 44 ld [ %i0 + 0x44 ], %i5
printf ("rtl: sym:load: data=0x%08" PRIx32 " name=0x%08" PRIx32
4000f574: 33 10 00 c5 sethi %hi(0x40031400), %i1
gsym->data = data & 0xffff;
4000f578: 35 00 00 3f sethi %hi(0xfc00), %i2
printf ("rtl: sym:add:%-2d name:%-20s bind:%-2d type:%-2d val:%8p sect:%d\n",
4000f57c: 37 10 00 c5 sethi %hi(0x40031400), %i3
for (sym = 0, gsym = obj->global_table; sym < rap->symbols; ++sym)
4000f580: b8 10 20 00 clr %i4
printf ("rtl: sym:load: data=0x%08" PRIx32 " name=0x%08" PRIx32
4000f584: b2 16 63 38 or %i1, 0x338, %i1
gsym->data = data & 0xffff;
4000f588: b4 16 a3 ff or %i2, 0x3ff, %i2
printf ("rtl: sym:add:%-2d name:%-20s bind:%-2d type:%-2d val:%8p sect:%d\n",
4000f58c: b6 16 e3 90 or %i3, 0x390, %i3
for (sym = 0, gsym = obj->global_table; sym < rap->symbols; ++sym)
4000f590: c4 07 bf f0 ld [ %fp + -16 ], %g2
4000f594: 80 a0 80 1c cmp %g2, %i4
4000f598: 08 80 00 88 bleu 4000f7b8 <rtems_rtl_rap_file_load+0x728>
4000f59c: d0 07 bf 88 ld [ %fp + -120 ], %o0
if (!rtems_rtl_rap_read_uint32 (rap->decomp, &data) ||
4000f5a0: 7f ff fe 25 call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f5a4: 92 07 bf 70 add %fp, -144, %o1
4000f5a8: 80 a2 20 00 cmp %o0, 0
4000f5ac: 02 80 00 7c be 4000f79c <rtems_rtl_rap_file_load+0x70c>
<== NEVER TAKEN
4000f5b0: d0 07 bf 88 ld [ %fp + -120 ], %o0
!rtems_rtl_rap_read_uint32 (rap->decomp, &name) ||
4000f5b4: 7f ff fe 20 call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f5b8: 92 07 bf 74 add %fp, -140, %o1
if (!rtems_rtl_rap_read_uint32 (rap->decomp, &data) ||
4000f5bc: 80 a2 20 00 cmp %o0, 0
4000f5c0: 02 80 00 77 be 4000f79c <rtems_rtl_rap_file_load+0x70c>
<== NEVER TAKEN
4000f5c4: d0 07 bf 88 ld [ %fp + -120 ], %o0
!rtems_rtl_rap_read_uint32 (rap->decomp, &value))
4000f5c8: 7f ff fe 1b call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f5cc: 92 07 bf 78 add %fp, -136, %o1
!rtems_rtl_rap_read_uint32 (rap->decomp, &name) ||
4000f5d0: 80 a2 20 00 cmp %o0, 0
4000f5d4: 22 80 00 73 be,a 4000f7a0 <rtems_rtl_rap_file_load+0x710>
<== NEVER TAKEN
4000f5d8: d2 06 20 44 ld [ %i0 + 0x44 ], %o1
<== NOT EXECUTED
if (rtems_rtl_trace (RTEMS_RTL_TRACE_SYMBOL))
4000f5dc: 40 00 04 0a call 40010604 <rtems_rtl_trace>
4000f5e0: 90 10 20 20 mov 0x20, %o0
4000f5e4: 80 a2 20 00 cmp %o0, 0
4000f5e8: 22 80 00 08 be,a 4000f608 <rtems_rtl_rap_file_load+0x578>
<== ALWAYS TAKEN
4000f5ec: d0 07 bf e4 ld [ %fp + -28 ], %o0
printf ("rtl: sym:load: data=0x%08" PRIx32 " name=0x%08" PRIx32
4000f5f0: d6 07 bf 78 ld [ %fp + -136 ], %o3
<== NOT EXECUTED
4000f5f4: d4 07 bf 74 ld [ %fp + -140 ], %o2
<== NOT EXECUTED
4000f5f8: d2 07 bf 70 ld [ %fp + -144 ], %o1
<== NOT EXECUTED
4000f5fc: 40 00 24 d3 call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000f600: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
if (rtems_rtl_symbol_global_find (rap->strtab + name) &&
4000f604: d0 07 bf e4 ld [ %fp + -28 ], %o0
<== NOT EXECUTED
4000f608: c4 07 bf 74 ld [ %fp + -140 ], %g2
4000f60c: 40 00 02 ba call 400100f4 <rtems_rtl_symbol_global_find>
4000f610: 90 02 00 02 add %o0, %g2, %o0
4000f614: 80 a2 20 00 cmp %o0, 0
4000f618: 02 80 00 07 be 4000f634 <rtems_rtl_rap_file_load+0x5a4>
<== ALWAYS TAKEN
4000f61c: d2 07 bf 70 ld [ %fp + -144 ], %o1
(ELF_ST_BIND (data & 0xffff) != STB_WEAK))
4000f620: 85 32 60 04 srl %o1, 4, %g2
<== NOT EXECUTED
4000f624: 84 08 af ff and %g2, 0xfff, %g2
<== NOT EXECUTED
if (rtems_rtl_symbol_global_find (rap->strtab + name) &&
4000f628: 80 a0 a0 02 cmp %g2, 2
<== NOT EXECUTED
4000f62c: 12 80 00 56 bne 4000f784 <rtems_rtl_rap_file_load+0x6f4>
<== NOT EXECUTED
4000f630: d4 07 bf e4 ld [ %fp + -28 ], %o2
<== NOT EXECUTED
symsect = rtems_rtl_obj_find_section_by_index (obj, data >> 16);
4000f634: 93 32 60 10 srl %o1, 0x10, %o1
4000f638: 7f ff fc 1b call 4000e6a4 <rtems_rtl_obj_find_section_by_index>
4000f63c: 90 10 00 18 mov %i0, %o0
if (!symsect)
4000f640: 86 92 20 00 orcc %o0, 0, %g3
4000f644: 02 80 00 43 be 4000f750 <rtems_rtl_rap_file_load+0x6c0>
<== NEVER TAKEN
4000f648: c4 07 bf e4 ld [ %fp + -28 ], %g2
gsym->name = rap->strtab + name;
4000f64c: c8 07 bf 74 ld [ %fp + -140 ], %g4
4000f650: 84 00 80 04 add %g2, %g4, %g2
node->next = NULL;
4000f654: c0 27 40 00 clr [ %i5 ]
if (rtems_rtl_trace (RTEMS_RTL_TRACE_SYMBOL))
4000f658: 90 10 20 20 mov 0x20, %o0
gsym->name = rap->strtab + name;
4000f65c: c4 27 60 08 st %g2, [ %i5 + 8 ]
gsym->value = (uint8_t*) (value + symsect->base);
4000f660: c4 07 bf 78 ld [ %fp + -136 ], %g2
4000f664: c6 00 e0 30 ld [ %g3 + 0x30 ], %g3
4000f668: 86 00 c0 02 add %g3, %g2, %g3
gsym->data = data & 0xffff;
4000f66c: c4 07 bf 70 ld [ %fp + -144 ], %g2
4000f670: 84 08 80 1a and %g2, %i2, %g2
gsym->value = (uint8_t*) (value + symsect->base);
4000f674: c6 27 60 0c st %g3, [ %i5 + 0xc ]
if (rtems_rtl_trace (RTEMS_RTL_TRACE_SYMBOL))
4000f678: 40 00 03 e3 call 40010604 <rtems_rtl_trace>
4000f67c: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
4000f680: 80 a2 20 00 cmp %o0, 0
4000f684: 22 80 00 0e be,a 4000f6bc <rtems_rtl_rap_file_load+0x62c>
<== ALWAYS TAKEN
4000f688: ba 07 60 14 add %i5, 0x14, %i5
(int) ELF_ST_BIND (data & 0xffff),
4000f68c: d8 07 bf 70 ld [ %fp + -144 ], %o4
<== NOT EXECUTED
gsym->value, (int) (data >> 16));
4000f690: 85 33 20 10 srl %o4, 0x10, %g2
<== NOT EXECUTED
printf ("rtl: sym:add:%-2d name:%-20s bind:%-2d type:%-2d val:%8p sect:%d\n",
4000f694: c4 23 a0 5c st %g2, [ %sp + 0x5c ]
<== NOT EXECUTED
(int) ELF_ST_BIND (data & 0xffff),
4000f698: 97 33 20 04 srl %o4, 4, %o3
<== NOT EXECUTED
printf ("rtl: sym:add:%-2d name:%-20s bind:%-2d type:%-2d val:%8p sect:%d\n",
4000f69c: da 07 60 0c ld [ %i5 + 0xc ], %o5
<== NOT EXECUTED
4000f6a0: d4 07 60 08 ld [ %i5 + 8 ], %o2
<== NOT EXECUTED
4000f6a4: 98 0b 20 0f and %o4, 0xf, %o4
<== NOT EXECUTED
4000f6a8: 96 0a ef ff and %o3, 0xfff, %o3
<== NOT EXECUTED
4000f6ac: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
4000f6b0: 40 00 24 a6 call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000f6b4: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
++gsym;
4000f6b8: ba 07 60 14 add %i5, 0x14, %i5
<== NOT EXECUTED
for (sym = 0, gsym = obj->global_table; sym < rap->symbols; ++sym)
4000f6bc: 10 bf ff b5 b 4000f590 <rtems_rtl_rap_file_load+0x500>
4000f6c0: b8 07 20 01 inc %i4
printf ("rtl: rap: datatype=%" PRIu32 "\n", rap.datatype);
4000f6c4: 11 10 00 c5 sethi %hi(0x40031400), %o0
<== NOT EXECUTED
4000f6c8: 40 00 24 a0 call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000f6cc: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 400315a8 <loaders+0xb8>
<== NOT EXECUTED
if (datatype != ELFDEFNNAME (MACHDEP_ENDIANNESS))
4000f6d0: 10 bf fe e3 b 4000f25c <rtems_rtl_rap_file_load+0x1cc>
<== NOT EXECUTED
4000f6d4: c2 07 bf a0 ld [ %fp + -96 ], %g1
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "invalid class");
4000f6d8: 13 10 00 c5 sethi %hi(0x40031400), %o1
<== NOT EXECUTED
return false;
4000f6dc: ae 10 20 00 clr %l7
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "invalid class");
4000f6e0: 7f ff f1 c3 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000f6e4: 92 12 61 f0 or %o1, 0x1f0, %o1
<== NOT EXECUTED
4000f6e8: b0 0d e0 ff and %l7, 0xff, %i0
<== NOT EXECUTED
4000f6ec: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f6f0: 81 e8 00 00 restore
<== NOT EXECUTED
obj->sec_num = (uint32_t*) malloc (sizeof (uint32_t) * obj->obj_num);
4000f6f4: 7f ff e1 74 call 40007cc4 <malloc>
4000f6f8: 91 2a 20 02 sll %o0, 2, %o0
4000f6fc: d0 26 20 80 st %o0, [ %i0 + 0x80 ]
if (!rtems_rtl_rap_read_uint32 (rap.decomp, &rap.rpathlen))
4000f700: 92 07 bf f8 add %fp, -8, %o1
4000f704: 90 10 00 1d mov %i5, %o0
4000f708: 7f ff fd cb call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f70c: ba 10 20 00 clr %i5
4000f710: 80 a2 20 00 cmp %o0, 0
4000f714: 02 bf fe 75 be 4000f0e8 <rtems_rtl_rap_file_load+0x58>
<== NEVER TAKEN
4000f718: ae 10 20 00 clr %l7
for (i = 0; i < obj->obj_num; ++i)
4000f71c: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
4000f720: 80 a0 40 1d cmp %g1, %i5
4000f724: 08 80 00 80 bleu 4000f924 <rtems_rtl_rap_file_load+0x894>
4000f728: d0 07 bf 88 ld [ %fp + -120 ], %o0
if (!rtems_rtl_rap_read_uint32 (rap.decomp, &(obj->sec_num[i])))
4000f72c: d2 06 20 80 ld [ %i0 + 0x80 ], %o1
4000f730: 83 2f 60 02 sll %i5, 2, %g1
4000f734: 7f ff fd c0 call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f738: 92 02 40 01 add %o1, %g1, %o1
4000f73c: 80 a2 20 00 cmp %o0, 0
4000f740: 02 bf fe 69 be 4000f0e4 <rtems_rtl_rap_file_load+0x54>
<== NEVER TAKEN
4000f744: ba 07 60 01 inc %i5
for (i = 0; i < obj->obj_num; ++i)
4000f748: 10 bf ff f6 b 4000f720 <rtems_rtl_rap_file_load+0x690>
4000f74c: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_SYMBOL, obj->global_table);
4000f750: d2 06 20 44 ld [ %i0 + 0x44 ], %o1
<== NOT EXECUTED
4000f754: 7f ff eb 5d call 4000a4c8 <rtems_rtl_alloc_del>
<== NOT EXECUTED
4000f758: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
obj->global_table = NULL;
4000f75c: c0 26 20 44 clr [ %i0 + 0x44 ]
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "section index not found: %" PRIu32, data >> 16);
4000f760: 13 10 00 c5 sethi %hi(0x40031400), %o1
<== NOT EXECUTED
obj->global_syms = 0;
4000f764: c0 26 20 48 clr [ %i0 + 0x48 ]
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "section index not found: %" PRIu32, data >> 16);
4000f768: 92 12 63 70 or %o1, 0x370, %o1
<== NOT EXECUTED
obj->global_size = 0;
4000f76c: c0 26 20 4c clr [ %i0 + 0x4c ]
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "section index not found: %" PRIu32, data >> 16);
4000f770: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
4000f774: 7f ff f1 9e call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000f778: d4 17 bf 70 lduh [ %fp + -144 ], %o2
<== NOT EXECUTED
return false;
4000f77c: 10 bf fe 5b b 4000f0e8 <rtems_rtl_rap_file_load+0x58>
<== NOT EXECUTED
4000f780: ae 10 20 00 clr %l7
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL,
4000f784: c2 07 bf 74 ld [ %fp + -140 ], %g1
<== NOT EXECUTED
4000f788: 13 10 00 c1 sethi %hi(0x40030400), %o1
<== NOT EXECUTED
4000f78c: 94 02 80 01 add %o2, %g1, %o2
<== NOT EXECUTED
4000f790: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
4000f794: 7f ff f1 96 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000f798: 92 12 62 90 or %o1, 0x290, %o1
<== NOT EXECUTED
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_SYMBOL, obj->global_table);
4000f79c: d2 06 20 44 ld [ %i0 + 0x44 ], %o1
<== NOT EXECUTED
4000f7a0: 7f ff eb 4a call 4000a4c8 <rtems_rtl_alloc_del>
<== NOT EXECUTED
4000f7a4: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
obj->global_table = NULL;
4000f7a8: c0 26 20 44 clr [ %i0 + 0x44 ]
<== NOT EXECUTED
obj->global_syms = 0;
4000f7ac: c0 26 20 48 clr [ %i0 + 0x48 ]
<== NOT EXECUTED
obj->global_size = 0;
4000f7b0: 10 bf fe 4d b 4000f0e4 <rtems_rtl_rap_file_load+0x54>
<== NOT EXECUTED
4000f7b4: c0 26 20 4c clr [ %i0 + 0x4c ]
<== NOT EXECUTED
if (obj->global_syms)
4000f7b8: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
4000f7bc: 80 a0 a0 00 cmp %g2, 0
4000f7c0: 02 80 00 04 be 4000f7d0 <rtems_rtl_rap_file_load+0x740>
<== NEVER TAKEN
4000f7c4: 01 00 00 00 nop
rtems_rtl_symbol_obj_add (obj);
4000f7c8: 40 00 03 49 call 400104ec <rtems_rtl_symbol_obj_add>
4000f7cc: 90 10 00 18 mov %i0, %o0
if (rtems_rtl_trace (RTEMS_RTL_TRACE_LOAD))
4000f7d0: 40 00 03 8d call 40010604 <rtems_rtl_trace>
4000f7d4: 90 10 20 04 mov 4, %o0
4000f7d8: 80 a2 20 00 cmp %o0, 0
4000f7dc: 02 80 00 06 be 4000f7f4 <rtems_rtl_rap_file_load+0x764>
<== ALWAYS TAKEN
4000f7e0: c4 07 bf 88 ld [ %fp + -120 ], %g2
printf ("rtl: rap: input relocs=%" PRIu32 "\n",
4000f7e4: d2 00 a0 24 ld [ %g2 + 0x24 ], %o1
<== NOT EXECUTED
4000f7e8: 11 10 00 c5 sethi %hi(0x40031400), %o0
<== NOT EXECUTED
4000f7ec: 40 00 24 57 call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000f7f0: 90 12 23 d8 or %o0, 0x3d8, %o0 ! 400317d8 <loaders+0x2e8>
<== NOT EXECUTED
if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
4000f7f4: 40 00 03 84 call 40010604 <rtems_rtl_trace>
4000f7f8: 90 10 20 40 mov 0x40, %o0
4000f7fc: 80 a2 20 00 cmp %o0, 0
4000f800: 22 80 00 06 be,a 4000f818 <rtems_rtl_rap_file_load+0x788>
<== ALWAYS TAKEN
4000f804: 90 10 24 00 mov 0x400, %o0
printf ("rtl: relocation\n");
4000f808: 11 10 00 c5 sethi %hi(0x40031400), %o0
<== NOT EXECUTED
4000f80c: 40 00 24 5e call 40018984 <__wrap_puts>
<== NOT EXECUTED
4000f810: 90 12 23 f8 or %o0, 0x3f8, %o0 ! 400317f8 <loaders+0x308>
<== NOT EXECUTED
symname_buffer = malloc (SYMNAME_BUFFER_SIZE);
4000f814: 90 10 24 00 mov 0x400, %o0
<== NOT EXECUTED
4000f818: 7f ff e1 2b call 40007cc4 <malloc>
4000f81c: a0 10 20 00 clr %l0
if (!symname_buffer)
4000f820: 80 a2 20 00 cmp %o0, 0
4000f824: 02 80 00 29 be 4000f8c8 <rtems_rtl_rap_file_load+0x838>
<== NEVER TAKEN
4000f828: ba 10 00 08 mov %o0, %i5
printf (" %2d: rel: type:%-2d off:%" PRIu32
4000f82c: 25 10 00 c6 sethi %hi(0x40031800), %l2
4000f830: 82 14 a1 00 or %l2, 0x100, %g1 ! 40031900 <loaders+0x410>
printf (" %2d: rela: type:%-2d off:%" PRIu32 " addend:%d"
4000f834: 05 10 00 c6 sethi %hi(0x40031800), %g2
printf (" %2d: rel: type:%-2d off:%" PRIu32
4000f838: c2 27 bf 50 st %g1, [ %fp + -176 ]
printf (" %2d: rela: type:%-2d off:%" PRIu32 " addend:%d"
4000f83c: 82 10 a0 a8 or %g2, 0xa8, %g1
4000f840: c2 27 bf 4c st %g1, [ %fp + -180 ]
printf (" %2d: info=%08" PRIx32 " offset=%" PRIu32
4000f844: 29 10 00 c6 sethi %hi(0x40031800), %l4
symname_size = (info & ~(3 << 30)) >> 8;
4000f848: 27 00 0f ff sethi %hi(0x3ffc00), %l3
printf (" %2d: info=%08" PRIx32 " offset=%" PRIu32
4000f84c: a8 15 20 68 or %l4, 0x68, %l4
symname_size = (info & ~(3 << 30)) >> 8;
4000f850: a6 14 e3 ff or %l3, 0x3ff, %l3
targetsect = rtems_rtl_obj_find_section (obj, rap_sections[section].name);
4000f854: 85 2c 20 03 sll %l0, 3, %g2
4000f858: f8 04 40 02 ld [ %l1 + %g2 ], %i4
uint32_t header = 0;
4000f85c: c0 27 bf 68 clr [ %fp + -152 ]
targetsect = rtems_rtl_obj_find_section (obj, rap_sections[section].name);
4000f860: 92 10 00 1c mov %i4, %o1
4000f864: 7f ff fb 85 call 4000e678 <rtems_rtl_obj_find_section>
4000f868: 90 10 00 18 mov %i0, %o0
if (!targetsect)
4000f86c: ac 92 20 00 orcc %o0, 0, %l6
4000f870: 02 80 00 0b be 4000f89c <rtems_rtl_rap_file_load+0x80c>
4000f874: d0 07 bf 88 ld [ %fp + -120 ], %o0
if (!rtems_rtl_rap_read_uint32 (rap->decomp, &header))
4000f878: 7f ff fd 6f call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f87c: 92 07 bf 68 add %fp, -152, %o1
4000f880: 80 a2 20 00 cmp %o0, 0
4000f884: 02 80 00 d1 be 4000fbc8 <rtems_rtl_rap_file_load+0xb38>
<== NEVER TAKEN
4000f888: c4 07 bf 68 ld [ %fp + -152 ], %g2
relocs = header & ~(1 << 31);
4000f88c: 35 20 00 00 sethi %hi(0x80000000), %i2
if (relocs && rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
4000f890: b4 a8 80 1a andncc %g2, %i2, %i2
4000f894: 12 80 00 3e bne 4000f98c <rtems_rtl_rap_file_load+0x8fc>
4000f898: ab 30 a0 1f srl %g2, 0x1f, %l5
for (section = 0; section < RTEMS_RTL_RAP_SECS; ++section)
4000f89c: a0 04 20 01 inc %l0
4000f8a0: 80 a4 20 06 cmp %l0, 6
4000f8a4: 12 bf ff ed bne 4000f858 <rtems_rtl_rap_file_load+0x7c8>
4000f8a8: 85 2c 20 03 sll %l0, 3, %g2
free (symname_buffer);
4000f8ac: 7f ff df 0a call 400074d4 <free>
4000f8b0: 90 10 00 1d mov %i5, %o0
rtems_rtl_obj_synchronize_cache (obj);
4000f8b4: 7f ff fb a1 call 4000e738 <rtems_rtl_obj_synchronize_cache>
4000f8b8: 90 10 00 18 mov %i0, %o0
4000f8bc: b0 0d e0 ff and %l7, 0xff, %i0
4000f8c0: 81 c7 e0 08 ret
4000f8c4: 81 e8 00 00 restore
rtems_rtl_set_error (ENOMEM, "no memory for local symbol name buffer");
4000f8c8: 90 10 20 0c mov 0xc, %o0
<== NOT EXECUTED
4000f8cc: 13 10 00 c6 sethi %hi(0x40031800), %o1
<== NOT EXECUTED
return false;
4000f8d0: ae 10 20 00 clr %l7
<== NOT EXECUTED
rtems_rtl_set_error (ENOMEM, "no memory for local symbol name buffer");
4000f8d4: 7f ff f1 46 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000f8d8: 92 12 60 08 or %o1, 8, %o1
<== NOT EXECUTED
4000f8dc: b0 0d e0 ff and %l7, 0xff, %i0
<== NOT EXECUTED
4000f8e0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f8e4: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_SYMBOL, obj->global_table);
4000f8e8: d2 06 20 44 ld [ %i0 + 0x44 ], %o1
<== NOT EXECUTED
4000f8ec: 7f ff ea f7 call 4000a4c8 <rtems_rtl_alloc_del>
<== NOT EXECUTED
4000f8f0: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
4000f8f4: b0 0d e0 ff and %l7, 0xff, %i0
<== NOT EXECUTED
4000f8f8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f8fc: 81 e8 00 00 restore
<== NOT EXECUTED
obj->global_size = 0;
4000f900: c0 26 20 4c clr [ %i0 + 0x4c ]
<== NOT EXECUTED
rtems_rtl_set_error (ENOMEM, "no memory for obj global syms");
4000f904: 90 10 20 0c mov 0xc, %o0
<== NOT EXECUTED
4000f908: 13 10 00 c1 sethi %hi(0x40030400), %o1
<== NOT EXECUTED
return false;
4000f90c: ae 10 20 00 clr %l7
<== NOT EXECUTED
rtems_rtl_set_error (ENOMEM, "no memory for obj global syms");
4000f910: 7f ff f1 37 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000f914: 92 12 62 d0 or %o1, 0x2d0, %o1
<== NOT EXECUTED
4000f918: b0 0d e0 ff and %l7, 0xff, %i0
<== NOT EXECUTED
4000f91c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f920: 81 e8 00 00 restore
<== NOT EXECUTED
if (!rtems_rtl_rap_read_uint32 (rap.decomp, &rap.strtable_size))
4000f924: 7f ff fd 44 call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f928: 92 07 bf f4 add %fp, -12, %o1
4000f92c: 80 a2 20 00 cmp %o0, 0
4000f930: 02 bf fd ee be 4000f0e8 <rtems_rtl_rap_file_load+0x58>
<== NEVER TAKEN
4000f934: ae 10 20 00 clr %l7
if (rtems_rtl_trace (RTEMS_RTL_TRACE_DETAIL))
4000f938: 40 00 03 33 call 40010604 <rtems_rtl_trace>
4000f93c: 90 10 20 01 mov 1, %o0
4000f940: 80 a2 20 00 cmp %o0, 0
4000f944: 22 80 00 07 be,a 4000f960 <rtems_rtl_rap_file_load+0x8d0>
<== ALWAYS TAKEN
4000f948: c6 06 20 84 ld [ %i0 + 0x84 ], %g3
printf ("rtl: rap: details: obj_num=%" PRIu32 "\n", obj->obj_num);
4000f94c: d2 06 20 84 ld [ %i0 + 0x84 ], %o1
<== NOT EXECUTED
4000f950: 11 10 00 c5 sethi %hi(0x40031400), %o0
<== NOT EXECUTED
4000f954: 40 00 23 fd call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000f958: 90 12 22 58 or %o0, 0x258, %o0 ! 40031658 <loaders+0x168>
<== NOT EXECUTED
obj_detail_size = sizeof (struct link_map) * obj->obj_num;
4000f95c: c6 06 20 84 ld [ %i0 + 0x84 ], %g3
<== NOT EXECUTED
4000f960: ba 58 e0 34 smul %g3, 0x34, %i5
for (i = 0; i < obj->obj_num; ++i)
4000f964: 82 10 20 00 clr %g1
4000f968: 80 a0 40 03 cmp %g1, %g3
4000f96c: 02 80 00 b4 be 4000fc3c <rtems_rtl_rap_file_load+0xbac>
4000f970: 85 28 60 02 sll %g1, 2, %g2
obj_detail_size += (obj->sec_num[i] * sizeof (section_detail));
4000f974: c8 06 20 80 ld [ %i0 + 0x80 ], %g4
4000f978: c4 01 00 02 ld [ %g4 + %g2 ], %g2
4000f97c: 85 28 a0 04 sll %g2, 4, %g2
for (i = 0; i < obj->obj_num; ++i)
4000f980: 82 00 60 01 inc %g1
obj_detail_size += (obj->sec_num[i] * sizeof (section_detail));
4000f984: 10 bf ff f9 b 4000f968 <rtems_rtl_rap_file_load+0x8d8>
4000f988: ba 07 40 02 add %i5, %g2, %i5
if (relocs && rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
4000f98c: 40 00 03 1e call 40010604 <rtems_rtl_trace>
4000f990: 90 10 20 40 mov 0x40, %o0
4000f994: 80 a2 20 00 cmp %o0, 0
4000f998: 22 80 00 0d be,a 4000f9cc <rtems_rtl_rap_file_load+0x93c>
<== ALWAYS TAKEN
4000f99c: ea 27 bf 54 st %l5, [ %fp + -172 ]
printf ("rtl: relocation: %s: header: %08" PRIx32 " relocs: %d %s\n",
4000f9a0: 80 a5 60 00 cmp %l5, 0
<== NOT EXECUTED
4000f9a4: 02 80 00 a3 be 4000fc30 <rtems_rtl_rap_file_load+0xba0>
<== NOT EXECUTED
4000f9a8: d4 07 bf 68 ld [ %fp + -152 ], %o2
<== NOT EXECUTED
4000f9ac: 19 10 00 c5 sethi %hi(0x40031400), %o4
<== NOT EXECUTED
4000f9b0: 98 13 21 28 or %o4, 0x128, %o4 ! 40031528 <loaders+0x38>
<== NOT EXECUTED
4000f9b4: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
4000f9b8: 96 10 00 1a mov %i2, %o3
<== NOT EXECUTED
4000f9bc: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
4000f9c0: 40 00 23 e2 call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000f9c4: 90 12 20 30 or %o0, 0x30, %o0
<== NOT EXECUTED
if (((info & (1 << 31)) == 0) || is_rela)
4000f9c8: ea 27 bf 54 st %l5, [ %fp + -172 ]
<== NOT EXECUTED
printf ("rtl: relocation: %s: header: %08" PRIx32 " relocs: %d %s\n",
4000f9cc: b6 10 20 00 clr %i3
if (!rtems_rtl_rap_read_uint32 (rap->decomp, &info))
4000f9d0: d0 07 bf 88 ld [ %fp + -120 ], %o0
uint32_t info = 0;
4000f9d4: c0 27 bf 6c clr [ %fp + -148 ]
if (!rtems_rtl_rap_read_uint32 (rap->decomp, &info))
4000f9d8: 92 07 bf 6c add %fp, -148, %o1
uint32_t offset = 0;
4000f9dc: c0 27 bf 70 clr [ %fp + -144 ]
if (!rtems_rtl_rap_read_uint32 (rap->decomp, &info))
4000f9e0: 7f ff fd 15 call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f9e4: c0 27 bf 74 clr [ %fp + -140 ]
4000f9e8: 80 a2 20 00 cmp %o0, 0
4000f9ec: 02 80 00 77 be 4000fbc8 <rtems_rtl_rap_file_load+0xb38>
<== NEVER TAKEN
4000f9f0: d0 07 bf 88 ld [ %fp + -120 ], %o0
if (!rtems_rtl_rap_read_uint32 (rap->decomp, &offset))
4000f9f4: 7f ff fd 10 call 4000ee34 <rtems_rtl_rap_read_uint32>
4000f9f8: 92 07 bf 70 add %fp, -144, %o1
4000f9fc: 80 a2 20 00 cmp %o0, 0
4000fa00: 02 80 00 72 be 4000fbc8 <rtems_rtl_rap_file_load+0xb38>
<== NEVER TAKEN
4000fa04: c4 07 bf 6c ld [ %fp + -148 ], %g2
if (((info & (1 << 31)) == 0) || is_rela)
4000fa08: 80 a0 a0 00 cmp %g2, 0
4000fa0c: 16 80 00 05 bge 4000fa20 <rtems_rtl_rap_file_load+0x990>
4000fa10: c2 07 bf 54 ld [ %fp + -172 ], %g1
4000fa14: 80 a0 60 00 cmp %g1, 0
4000fa18: 02 80 00 08 be 4000fa38 <rtems_rtl_rap_file_load+0x9a8>
<== NEVER TAKEN
4000fa1c: 01 00 00 00 nop
if (!rtems_rtl_rap_read_uint32 (rap->decomp, &addend))
4000fa20: d0 07 bf 88 ld [ %fp + -120 ], %o0
4000fa24: 7f ff fd 04 call 4000ee34 <rtems_rtl_rap_read_uint32>
4000fa28: 92 07 bf 74 add %fp, -140, %o1
4000fa2c: 80 a2 20 00 cmp %o0, 0
4000fa30: 02 80 00 66 be 4000fbc8 <rtems_rtl_rap_file_load+0xb38>
<== NEVER TAKEN
4000fa34: 01 00 00 00 nop
if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
4000fa38: 40 00 02 f3 call 40010604 <rtems_rtl_trace>
4000fa3c: 90 10 20 40 mov 0x40, %o0 ! 40 <_TLS_Alignment+0x3f>
4000fa40: 80 a2 20 00 cmp %o0, 0
4000fa44: 02 80 00 09 be 4000fa68 <rtems_rtl_rap_file_load+0x9d8>
<== ALWAYS TAKEN
4000fa48: d2 07 bf 6c ld [ %fp + -148 ], %o1
printf (" %2d: info=%08" PRIx32 " offset=%" PRIu32
4000fa4c: d8 07 bf 74 ld [ %fp + -140 ], %o4
<== NOT EXECUTED
4000fa50: d6 07 bf 70 ld [ %fp + -144 ], %o3
<== NOT EXECUTED
4000fa54: d4 07 bf 6c ld [ %fp + -148 ], %o2
<== NOT EXECUTED
4000fa58: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4000fa5c: 40 00 23 bb call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000fa60: 90 10 00 14 mov %l4, %o0
<== NOT EXECUTED
type = info & 0xff;
4000fa64: d2 07 bf 6c ld [ %fp + -148 ], %o1
<== NOT EXECUTED
if ((info & (1 << 31)) == 0)
4000fa68: 80 a2 60 00 cmp %o1, 0
4000fa6c: 06 80 00 5b bl 4000fbd8 <rtems_rtl_rap_file_load+0xb48>
4000fa70: b2 0a 60 ff and %o1, 0xff, %i1
symsect = rtems_rtl_obj_find_section_by_index (obj, info >> 8);
4000fa74: 93 32 60 08 srl %o1, 8, %o1
4000fa78: 7f ff fb 0b call 4000e6a4 <rtems_rtl_obj_find_section_by_index>
4000fa7c: 90 10 00 18 mov %i0, %o0
if (!symsect)
4000fa80: 80 a2 20 00 cmp %o0, 0
4000fa84: 02 80 00 51 be 4000fbc8 <rtems_rtl_rap_file_load+0xb38>
<== NEVER TAKEN
4000fa88: c4 07 bf 74 ld [ %fp + -140 ], %g2
symvalue = (Elf_Addr) symsect->base + addend;
4000fa8c: f8 02 20 30 ld [ %o0 + 0x30 ], %i4
4000fa90: b8 07 00 02 add %i4, %g2, %i4
const char* symname = NULL;
4000fa94: a4 10 20 00 clr %l2
4000fa98: c6 07 bf 70 ld [ %fp + -144 ], %g3
if (is_rela)
4000fa9c: 80 a5 60 00 cmp %l5, 0
4000faa0: 02 80 00 2e be 4000fb58 <rtems_rtl_rap_file_load+0xac8>
<== NEVER TAKEN
4000faa4: c6 27 bf 78 st %g3, [ %fp + -136 ]
rela.r_info = type;
4000faa8: f2 27 bf 7c st %i1, [ %fp + -132 ]
if ((info & (1 << 31)) == 0)
4000faac: c6 07 bf 6c ld [ %fp + -148 ], %g3
4000fab0: 80 a0 e0 00 cmp %g3, 0
4000fab4: 06 80 00 27 bl 4000fb50 <rtems_rtl_rap_file_load+0xac0>
4000fab8: c6 07 bf 74 ld [ %fp + -140 ], %g3
rela.r_addend = 0;
4000fabc: c0 27 bf 80 clr [ %fp + -128 ]
if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
4000fac0: 40 00 02 d1 call 40010604 <rtems_rtl_trace>
4000fac4: 90 10 20 40 mov 0x40, %o0
4000fac8: 80 a2 20 00 cmp %o0, 0
4000facc: 02 80 00 12 be 4000fb14 <rtems_rtl_rap_file_load+0xa84>
<== ALWAYS TAKEN
4000fad0: 9a 10 00 1c mov %i4, %o5
printf (" %2d: rela: type:%-2d off:%" PRIu32 " addend:%d"
4000fad4: c0 27 bf 58 clr [ %fp + -168 ]
<== NOT EXECUTED
4000fad8: 9a 10 00 12 mov %l2, %o5
<== NOT EXECUTED
4000fadc: c0 27 bf 5c clr [ %fp + -164 ]
<== NOT EXECUTED
4000fae0: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
4000fae4: c6 07 bf 58 ld [ %fp + -168 ], %g3
<== NOT EXECUTED
4000fae8: c6 23 a0 5c st %g3, [ %sp + 0x5c ]
<== NOT EXECUTED
4000faec: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4000faf0: c6 07 bf 5c ld [ %fp + -164 ], %g3
<== NOT EXECUTED
4000faf4: c0 23 a0 64 clr [ %sp + 0x64 ]
<== NOT EXECUTED
4000faf8: f8 23 a0 68 st %i4, [ %sp + 0x68 ]
<== NOT EXECUTED
4000fafc: c6 23 a0 60 st %g3, [ %sp + 0x60 ]
<== NOT EXECUTED
4000fb00: d0 07 bf 4c ld [ %fp + -180 ], %o0
<== NOT EXECUTED
4000fb04: d8 07 bf 74 ld [ %fp + -140 ], %o4
<== NOT EXECUTED
4000fb08: 40 00 23 90 call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000fb0c: d6 07 bf 70 ld [ %fp + -144 ], %o3
<== NOT EXECUTED
if (!rtems_rtl_elf_relocate_rela (obj, &rela, targetsect,
4000fb10: 9a 10 00 1c mov %i4, %o5
<== NOT EXECUTED
4000fb14: 98 10 20 00 clr %o4
4000fb18: 96 10 00 12 mov %l2, %o3
4000fb1c: 94 10 00 16 mov %l6, %o2
4000fb20: 92 07 bf 78 add %fp, -136, %o1
4000fb24: 7f ff f1 5c call 4000c094 <rtems_rtl_elf_relocate_rela>
4000fb28: 90 10 00 18 mov %i0, %o0
4000fb2c: 80 a2 20 00 cmp %o0, 0
4000fb30: 02 80 00 26 be 4000fbc8 <rtems_rtl_rap_file_load+0xb38>
<== NEVER TAKEN
4000fb34: 01 00 00 00 nop
for (r = 0; r < relocs; ++r)
4000fb38: b6 06 e0 01 inc %i3
4000fb3c: 80 a6 80 1b cmp %i2, %i3
4000fb40: 12 bf ff a5 bne 4000f9d4 <rtems_rtl_rap_file_load+0x944>
4000fb44: d0 07 bf 88 ld [ %fp + -120 ], %o0
for (section = 0; section < RTEMS_RTL_RAP_SECS; ++section)
4000fb48: 10 bf ff 56 b 4000f8a0 <rtems_rtl_rap_file_load+0x810>
4000fb4c: a0 04 20 01 inc %l0
else rela.r_addend = addend;
4000fb50: 10 bf ff dc b 4000fac0 <rtems_rtl_rap_file_load+0xa30>
4000fb54: c6 27 bf 80 st %g3, [ %fp + -128 ]
if (rtems_rtl_trace (RTEMS_RTL_TRACE_RELOC))
4000fb58: 90 10 20 40 mov 0x40, %o0
<== NOT EXECUTED
4000fb5c: 40 00 02 aa call 40010604 <rtems_rtl_trace>
<== NOT EXECUTED
4000fb60: f2 27 bf 7c st %i1, [ %fp + -132 ]
<== NOT EXECUTED
4000fb64: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000fb68: 02 80 00 0f be 4000fba4 <rtems_rtl_rap_file_load+0xb14>
<== NOT EXECUTED
4000fb6c: 9a 10 00 1c mov %i4, %o5
<== NOT EXECUTED
printf (" %2d: rel: type:%-2d off:%" PRIu32
4000fb70: c0 23 a0 60 clr [ %sp + 0x60 ]
<== NOT EXECUTED
4000fb74: 9a 10 20 00 clr %o5
<== NOT EXECUTED
4000fb78: f8 23 a0 64 st %i4, [ %sp + 0x64 ]
<== NOT EXECUTED
4000fb7c: 98 10 00 12 mov %l2, %o4
<== NOT EXECUTED
4000fb80: c0 23 a0 5c clr [ %sp + 0x5c ]
<== NOT EXECUTED
4000fb84: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
4000fb88: d6 07 bf 70 ld [ %fp + -144 ], %o3
<== NOT EXECUTED
4000fb8c: d0 07 bf 50 ld [ %fp + -176 ], %o0
<== NOT EXECUTED
4000fb90: c0 27 bf 58 clr [ %fp + -168 ]
<== NOT EXECUTED
4000fb94: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
4000fb98: 40 00 23 6c call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000fb9c: c0 27 bf 5c clr [ %fp + -164 ]
<== NOT EXECUTED
if (!rtems_rtl_elf_relocate_rel (obj, &rel, targetsect,
4000fba0: 9a 10 00 1c mov %i4, %o5
<== NOT EXECUTED
4000fba4: 98 10 20 00 clr %o4
<== NOT EXECUTED
4000fba8: 96 10 00 12 mov %l2, %o3
<== NOT EXECUTED
4000fbac: 94 10 00 16 mov %l6, %o2
<== NOT EXECUTED
4000fbb0: 92 07 bf 78 add %fp, -136, %o1
<== NOT EXECUTED
4000fbb4: 7f ff f1 be call 4000c2ac <rtems_rtl_elf_relocate_rel>
<== NOT EXECUTED
4000fbb8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000fbbc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000fbc0: 32 bf ff df bne,a 4000fb3c <rtems_rtl_rap_file_load+0xaac>
<== NOT EXECUTED
4000fbc4: b6 06 e0 01 inc %i3
<== NOT EXECUTED
free (symname_buffer);
4000fbc8: 7f ff de 43 call 400074d4 <free>
<== NOT EXECUTED
4000fbcc: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
return false;
4000fbd0: 10 bf fd 46 b 4000f0e8 <rtems_rtl_rap_file_load+0x58>
<== NOT EXECUTED
4000fbd4: ae 10 20 00 clr %l7
<== NOT EXECUTED
else if (rtems_rtl_elf_rel_resolve_sym (type))
4000fbd8: 7f ff f1 29 call 4000c07c <rtems_rtl_elf_rel_resolve_sym>
4000fbdc: 90 10 00 19 mov %i1, %o0
4000fbe0: 80 a2 20 00 cmp %o0, 0
4000fbe4: 02 80 00 da be 4000ff4c <rtems_rtl_rap_file_load+0xebc>
<== NEVER TAKEN
4000fbe8: b8 10 20 00 clr %i4
symname_size = (info & ~(3 << 30)) >> 8;
4000fbec: c6 07 bf 6c ld [ %fp + -148 ], %g3
4000fbf0: 85 30 e0 08 srl %g3, 8, %g2
4000fbf4: a4 08 80 13 and %g2, %l3, %l2
if ((info & (1 << 30)) != 0)
4000fbf8: 05 10 00 00 sethi %hi(0x40000000), %g2
4000fbfc: 80 88 c0 02 btst %g3, %g2
4000fc00: 02 80 00 c8 be 4000ff20 <rtems_rtl_rap_file_load+0xe90>
4000fc04: 80 a4 a3 ff cmp %l2, 0x3ff
symname = rap->strtab + symname_size;
4000fc08: c4 07 bf e4 ld [ %fp + -28 ], %g2
4000fc0c: a4 00 80 12 add %g2, %l2, %l2
symbol = rtems_rtl_symbol_obj_find (obj, symname);
4000fc10: 92 10 00 12 mov %l2, %o1
4000fc14: 40 00 02 11 call 40010458 <rtems_rtl_symbol_obj_find>
4000fc18: 90 10 00 18 mov %i0, %o0
if (!symbol)
4000fc1c: 80 a2 20 00 cmp %o0, 0
4000fc20: 02 80 00 3c be 4000fd10 <rtems_rtl_rap_file_load+0xc80>
<== NEVER TAKEN
4000fc24: 94 10 00 12 mov %l2, %o2
symvalue = (Elf_Addr) symbol->value;
4000fc28: 10 bf ff 9c b 4000fa98 <rtems_rtl_rap_file_load+0xa08>
4000fc2c: f8 02 20 0c ld [ %o0 + 0xc ], %i4
printf ("rtl: relocation: %s: header: %08" PRIx32 " relocs: %d %s\n",
4000fc30: 19 10 00 c5 sethi %hi(0x40031400), %o4
<== NOT EXECUTED
4000fc34: 10 bf ff 60 b 4000f9b4 <rtems_rtl_rap_file_load+0x924>
<== NOT EXECUTED
4000fc38: 98 13 21 30 or %o4, 0x130, %o4 ! 40031530 <loaders+0x40>
<== NOT EXECUTED
detail = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_OBJECT,
4000fc3c: d2 07 bf f4 ld [ %fp + -12 ], %o1
4000fc40: 94 10 20 01 mov 1, %o2
4000fc44: 92 07 40 09 add %i5, %o1, %o1
4000fc48: 7f ff e9 f7 call 4000a424 <rtems_rtl_alloc_new>
4000fc4c: 90 10 20 00 clr %o0
if (!detail)
4000fc50: b8 92 20 00 orcc %o0, 0, %i4
4000fc54: 02 80 00 b1 be 4000ff18 <rtems_rtl_rap_file_load+0xe88>
<== NEVER TAKEN
4000fc58: d4 07 bf f4 ld [ %fp + -12 ], %o2
if (!rtems_rtl_obj_comp_read (rap->decomp,
4000fc5c: d0 07 bf 88 ld [ %fp + -120 ], %o0
rap->strtable = detail + obj_detail_size;
4000fc60: 92 07 00 1d add %i4, %i5, %o1
if (!rtems_rtl_obj_comp_read (rap->decomp,
4000fc64: 7f ff f5 c6 call 4000d37c <rtems_rtl_obj_comp_read>
4000fc68: d2 27 bf fc st %o1, [ %fp + -4 ]
4000fc6c: 80 a2 20 00 cmp %o0, 0
4000fc70: 02 80 00 a5 be 4000ff04 <rtems_rtl_rap_file_load+0xe74>
<== NEVER TAKEN
4000fc74: ae 10 00 08 mov %o0, %l7
obj->linkmap = (struct link_map*) detail;
4000fc78: f8 26 20 88 st %i4, [ %i0 + 0x88 ]
if (rtems_rtl_trace (RTEMS_RTL_TRACE_DETAIL))
4000fc7c: 40 00 02 62 call 40010604 <rtems_rtl_trace>
4000fc80: 90 10 20 01 mov 1, %o0
4000fc84: 80 a2 20 00 cmp %o0, 0
4000fc88: 02 80 00 85 be 4000fe9c <rtems_rtl_rap_file_load+0xe0c>
<== ALWAYS TAKEN
4000fc8c: 39 10 00 c5 sethi %hi(0x40031400), %i4
if (rap->rpathlen > 0)
4000fc90: f6 07 bf f8 ld [ %fp + -8 ], %i3
<== NOT EXECUTED
4000fc94: a0 96 e0 00 orcc %i3, 0, %l0
<== NOT EXECUTED
4000fc98: 32 80 00 7e bne,a 4000fe90 <rtems_rtl_rap_file_load+0xe00>
<== NOT EXECUTED
4000fc9c: 11 10 00 c5 sethi %hi(0x40031400), %o0
<== NOT EXECUTED
for (i = 0; i < obj->obj_num; ++i)
4000fca0: e2 06 20 84 ld [ %i0 + 0x84 ], %l1
tmp1->name = rap->strtable + pos;
4000fca4: e6 07 bf fc ld [ %fp + -4 ], %l3
4000fca8: fa 06 20 88 ld [ %i0 + 0x88 ], %i5
tmp1->rpathlen = rap->rpathlen;
4000fcac: a4 10 20 00 clr %l2
4000fcb0: b4 10 20 00 clr %i2
tmp1->name = rap->strtable + pos;
4000fcb4: 82 04 c0 10 add %l3, %l0, %g1
tmp1->sec_num = obj->sec_num[i];
4000fcb8: 85 2e a0 02 sll %i2, 2, %g2
tmp1 = obj->linkmap + i;
4000fcbc: b8 07 40 12 add %i5, %l2, %i4
for (i = 0; i < obj->obj_num; ++i)
4000fcc0: 80 a6 80 11 cmp %i2, %l1
4000fcc4: 02 80 00 1c be 4000fd34 <rtems_rtl_rap_file_load+0xca4>
4000fcc8: 90 10 00 01 mov %g1, %o0
tmp1->sec_num = obj->sec_num[i];
4000fccc: c6 06 20 80 ld [ %i0 + 0x80 ], %g3
4000fcd0: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
tmp1->name = rap->strtable + pos;
4000fcd4: c2 27 40 12 st %g1, [ %i5 + %l2 ]
tmp1->sec_num = obj->sec_num[i];
4000fcd8: c4 27 20 04 st %g2, [ %i4 + 4 ]
tmp1->rpathlen = rap->rpathlen;
4000fcdc: f6 27 20 24 st %i3, [ %i4 + 0x24 ]
pos += strlen (tmp1->name) + 1;
4000fce0: 40 00 33 df call 4001cc5c <strlen>
4000fce4: e6 27 20 28 st %l3, [ %i4 + 0x28 ]
tmp1->l_prev = tmp1 - 1;
4000fce8: 82 07 3f cc add %i4, -52, %g1
pos += strlen (tmp1->name) + 1;
4000fcec: 90 02 20 01 inc %o0
if (!i)
4000fcf0: 80 a6 a0 00 cmp %i2, 0
4000fcf4: 12 80 00 0c bne 4000fd24 <rtems_rtl_rap_file_load+0xc94>
4000fcf8: a0 04 00 08 add %l0, %o0, %l0
tmp1->l_next = NULL;
4000fcfc: c0 27 20 2c clr [ %i4 + 0x2c ]
tmp1->l_prev = NULL;
4000fd00: c0 27 20 30 clr [ %i4 + 0x30 ]
for (i = 0; i < obj->obj_num; ++i)
4000fd04: b4 06 a0 01 inc %i2
4000fd08: 10 bf ff eb b 4000fcb4 <rtems_rtl_rap_file_load+0xc24>
4000fd0c: a4 04 a0 34 add %l2, 0x34, %l2
rtems_rtl_set_error (EINVAL, "global symbol not found: %s", symname);
4000fd10: 13 10 00 c1 sethi %hi(0x40030400), %o1
<== NOT EXECUTED
4000fd14: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
4000fd18: 7f ff f0 35 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000fd1c: 92 12 63 80 or %o1, 0x380, %o1
<== NOT EXECUTED
4000fd20: 30 bf ff aa b,a 4000fbc8 <rtems_rtl_rap_file_load+0xb38>
<== NOT EXECUTED
(tmp1 - 1)->l_next = tmp1;
4000fd24: f8 27 3f f8 st %i4, [ %i4 + -8 ]
tmp1->l_prev = tmp1 - 1;
4000fd28: c2 27 20 30 st %g1, [ %i4 + 0x30 ]
tmp1->l_next = NULL;
4000fd2c: 10 bf ff f6 b 4000fd04 <rtems_rtl_rap_file_load+0xc74>
4000fd30: c0 27 20 2c clr [ %i4 + 0x2c ]
tmp2 = (section_detail*) (obj->linkmap + obj->obj_num);
4000fd34: 82 5c 60 34 smul %l1, 0x34, %g1
printf ("File %d: %s\n", i, (obj->linkmap + i)->name);
4000fd38: 27 10 00 c5 sethi %hi(0x40031400), %l3
printf ("Section: %d sections\n", (unsigned int) obj->sec_num[i]);
4000fd3c: 25 10 00 c5 sethi %hi(0x40031400), %l2
offset = offset & 0xfffffff;
4000fd40: 21 03 ff ff sethi %hi(0xffffc00), %l0
printf ("name:%16s offset:0x%08x rap_id:%d size:0x%x\n",
4000fd44: 35 10 00 c5 sethi %hi(0x40031400), %i2
tmp2 = (section_detail*) (obj->linkmap + obj->obj_num);
4000fd48: ba 07 40 01 add %i5, %g1, %i5
4000fd4c: b6 10 20 00 clr %i3
for (i = 0; i < obj->obj_num; ++i)
4000fd50: b8 10 20 00 clr %i4
printf ("File %d: %s\n", i, (obj->linkmap + i)->name);
4000fd54: a6 14 e2 98 or %l3, 0x298, %l3
printf ("Section: %d sections\n", (unsigned int) obj->sec_num[i]);
4000fd58: a4 14 a2 a8 or %l2, 0x2a8, %l2
offset = offset & 0xfffffff;
4000fd5c: a0 14 23 ff or %l0, 0x3ff, %l0
printf ("name:%16s offset:0x%08x rap_id:%d size:0x%x\n",
4000fd60: b4 16 a2 c0 or %i2, 0x2c0, %i2
for (i = 0; i < obj->obj_num; ++i)
4000fd64: 80 a7 00 11 cmp %i4, %l1
4000fd68: 1a bf fd a4 bcc 4000f3f8 <rtems_rtl_rap_file_load+0x368>
4000fd6c: 90 10 20 01 mov 1, %o0
if (rtems_rtl_trace (RTEMS_RTL_TRACE_DETAIL))
4000fd70: 40 00 02 25 call 40010604 <rtems_rtl_trace>
4000fd74: a3 2f 20 02 sll %i4, 2, %l1
4000fd78: 80 a2 20 00 cmp %o0, 0
4000fd7c: 02 80 00 0b be 4000fda8 <rtems_rtl_rap_file_load+0xd18>
<== ALWAYS TAKEN
4000fd80: c2 06 20 88 ld [ %i0 + 0x88 ], %g1
printf ("File %d: %s\n", i, (obj->linkmap + i)->name);
4000fd84: d4 00 40 1b ld [ %g1 + %i3 ], %o2
<== NOT EXECUTED
4000fd88: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
4000fd8c: 40 00 22 ef call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000fd90: 90 10 00 13 mov %l3, %o0
<== NOT EXECUTED
printf ("Section: %d sections\n", (unsigned int) obj->sec_num[i]);
4000fd94: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
<== NOT EXECUTED
4000fd98: d2 00 40 11 ld [ %g1 + %l1 ], %o1
<== NOT EXECUTED
4000fd9c: 40 00 22 eb call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000fda0: 90 10 00 12 mov %l2, %o0
<== NOT EXECUTED
obj->linkmap[i].sec_detail = tmp2;
4000fda4: c2 06 20 88 ld [ %i0 + 0x88 ], %g1
<== NOT EXECUTED
4000fda8: 82 00 40 1b add %g1, %i3, %g1
4000fdac: fa 20 60 08 st %i5, [ %g1 + 8 ]
for (j = 0; j < obj->sec_num[i]; ++j)
4000fdb0: a8 10 20 00 clr %l4
4000fdb4: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
4000fdb8: c2 00 40 11 ld [ %g1 + %l1 ], %g1
4000fdbc: 80 a0 40 14 cmp %g1, %l4
4000fdc0: 08 80 00 30 bleu 4000fe80 <rtems_rtl_rap_file_load+0xdf0>
4000fdc4: d0 07 bf 88 ld [ %fp + -120 ], %o0
if (!rtems_rtl_rap_read_uint32 (rap->decomp, &name) ||
4000fdc8: 7f ff fc 1b call 4000ee34 <rtems_rtl_rap_read_uint32>
4000fdcc: 92 07 bf 70 add %fp, -144, %o1
4000fdd0: 80 a2 20 00 cmp %o0, 0
4000fdd4: 02 80 00 25 be 4000fe68 <rtems_rtl_rap_file_load+0xdd8>
<== NEVER TAKEN
4000fdd8: d0 07 bf 88 ld [ %fp + -120 ], %o0
!rtems_rtl_rap_read_uint32 (rap->decomp, &offset) ||
4000fddc: 7f ff fc 16 call 4000ee34 <rtems_rtl_rap_read_uint32>
4000fde0: 92 07 bf 74 add %fp, -140, %o1
if (!rtems_rtl_rap_read_uint32 (rap->decomp, &name) ||
4000fde4: 80 a2 20 00 cmp %o0, 0
4000fde8: 02 80 00 20 be 4000fe68 <rtems_rtl_rap_file_load+0xdd8>
<== NEVER TAKEN
4000fdec: d0 07 bf 88 ld [ %fp + -120 ], %o0
!rtems_rtl_rap_read_uint32 (rap->decomp, &size))
4000fdf0: 7f ff fc 11 call 4000ee34 <rtems_rtl_rap_read_uint32>
4000fdf4: 92 07 bf 78 add %fp, -136, %o1
!rtems_rtl_rap_read_uint32 (rap->decomp, &offset) ||
4000fdf8: 80 a2 20 00 cmp %o0, 0
4000fdfc: 02 80 00 1b be 4000fe68 <rtems_rtl_rap_file_load+0xdd8>
<== NEVER TAKEN
4000fe00: c2 07 bf 74 ld [ %fp + -140 ], %g1
offset = offset & 0xfffffff;
4000fe04: 86 08 40 10 and %g1, %l0, %g3
4000fe08: c6 27 bf 74 st %g3, [ %fp + -140 ]
rap_id = offset >> 28;
4000fe0c: 83 30 60 1c srl %g1, 0x1c, %g1
tmp2->name = rap->strtable + name;
4000fe10: c4 07 bf fc ld [ %fp + -4 ], %g2
4000fe14: c8 07 bf 70 ld [ %fp + -144 ], %g4
tmp2->offset = offset;
4000fe18: c6 27 60 04 st %g3, [ %i5 + 4 ]
tmp2->name = rap->strtable + name;
4000fe1c: 84 00 80 04 add %g2, %g4, %g2
tmp2->rap_id = rap_id;
4000fe20: c2 27 60 0c st %g1, [ %i5 + 0xc ]
if (rtems_rtl_trace (RTEMS_RTL_TRACE_DETAIL))
4000fe24: 90 10 20 01 mov 1, %o0
tmp2->size = size;
4000fe28: c2 07 bf 78 ld [ %fp + -136 ], %g1
4000fe2c: c2 27 60 08 st %g1, [ %i5 + 8 ]
for (j = 0; j < obj->sec_num[i]; ++j)
4000fe30: a8 05 20 01 inc %l4
if (rtems_rtl_trace (RTEMS_RTL_TRACE_DETAIL))
4000fe34: 40 00 01 f4 call 40010604 <rtems_rtl_trace>
4000fe38: c4 27 40 00 st %g2, [ %i5 ]
4000fe3c: 80 a2 20 00 cmp %o0, 0
4000fe40: 22 bf ff dd be,a 4000fdb4 <rtems_rtl_rap_file_load+0xd24>
<== ALWAYS TAKEN
4000fe44: ba 07 60 10 add %i5, 0x10, %i5
printf ("name:%16s offset:0x%08x rap_id:%d size:0x%x\n",
4000fe48: d8 07 60 08 ld [ %i5 + 8 ], %o4
<== NOT EXECUTED
4000fe4c: d6 07 60 0c ld [ %i5 + 0xc ], %o3
<== NOT EXECUTED
4000fe50: d4 07 60 04 ld [ %i5 + 4 ], %o2
<== NOT EXECUTED
4000fe54: d2 07 40 00 ld [ %i5 ], %o1
<== NOT EXECUTED
4000fe58: 40 00 22 bc call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000fe5c: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
tmp2 += 1;
4000fe60: 10 bf ff d5 b 4000fdb4 <rtems_rtl_rap_file_load+0xd24>
<== NOT EXECUTED
4000fe64: ba 07 60 10 add %i5, 0x10, %i5
<== NOT EXECUTED
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_SYMBOL, obj->linkmap);
4000fe68: d2 06 20 88 ld [ %i0 + 0x88 ], %o1
<== NOT EXECUTED
4000fe6c: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
4000fe70: 7f ff e9 96 call 4000a4c8 <rtems_rtl_alloc_del>
<== NOT EXECUTED
4000fe74: ae 10 20 00 clr %l7
<== NOT EXECUTED
obj->linkmap = NULL;
4000fe78: 10 bf fc 9c b 4000f0e8 <rtems_rtl_rap_file_load+0x58>
<== NOT EXECUTED
4000fe7c: c0 26 20 88 clr [ %i0 + 0x88 ]
<== NOT EXECUTED
4000fe80: e2 06 20 84 ld [ %i0 + 0x84 ], %l1
for (i = 0; i < obj->obj_num; ++i)
4000fe84: b8 07 20 01 inc %i4
4000fe88: 10 bf ff b7 b 4000fd64 <rtems_rtl_rap_file_load+0xcd4>
4000fe8c: b6 06 e0 34 add %i3, 0x34, %i3
printf ("File rpath:\n");
4000fe90: 40 00 22 bd call 40018984 <__wrap_puts>
<== NOT EXECUTED
4000fe94: 90 12 22 78 or %o0, 0x278, %o0
<== NOT EXECUTED
printf (" %s\n", rap->strtable + pos);
4000fe98: 39 10 00 c5 sethi %hi(0x40031400), %i4
<== NOT EXECUTED
for (i = 0; i < obj->obj_num; ++i)
4000fe9c: ba 10 20 00 clr %i5
printf (" %s\n", rap->strtable + pos);
4000fea0: b8 17 22 88 or %i4, 0x288, %i4
while (pos < rap->rpathlen)
4000fea4: f6 07 bf f8 ld [ %fp + -8 ], %i3
4000fea8: 80 a7 40 1b cmp %i5, %i3
4000feac: 1a 80 00 11 bcc 4000fef0 <rtems_rtl_rap_file_load+0xe60>
<== ALWAYS TAKEN
4000feb0: a0 10 00 1b mov %i3, %l0
if (rtems_rtl_trace (RTEMS_RTL_TRACE_DETAIL))
4000feb4: 40 00 01 d4 call 40010604 <rtems_rtl_trace>
<== NOT EXECUTED
4000feb8: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
4000febc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000fec0: 22 80 00 07 be,a 4000fedc <rtems_rtl_rap_file_load+0xe4c>
<== NOT EXECUTED
4000fec4: d0 07 bf fc ld [ %fp + -4 ], %o0
<== NOT EXECUTED
printf (" %s\n", rap->strtable + pos);
4000fec8: d2 07 bf fc ld [ %fp + -4 ], %o1
<== NOT EXECUTED
4000fecc: 92 02 40 1d add %o1, %i5, %o1
<== NOT EXECUTED
4000fed0: 40 00 22 9e call 40018948 <__wrap_printf>
<== NOT EXECUTED
4000fed4: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
pos = pos + strlen (rap->strtable + pos) + 1;
4000fed8: d0 07 bf fc ld [ %fp + -4 ], %o0
<== NOT EXECUTED
4000fedc: 40 00 33 60 call 4001cc5c <strlen>
<== NOT EXECUTED
4000fee0: 90 02 00 1d add %o0, %i5, %o0
<== NOT EXECUTED
4000fee4: 90 02 20 01 inc %o0
<== NOT EXECUTED
4000fee8: 10 bf ff ef b 4000fea4 <rtems_rtl_rap_file_load+0xe14>
<== NOT EXECUTED
4000feec: ba 07 40 08 add %i5, %o0, %i5
<== NOT EXECUTED
if (rap->rpathlen > 0)
4000fef0: 80 a6 e0 00 cmp %i3, 0
4000fef4: 22 bf ff 6b be,a 4000fca0 <rtems_rtl_rap_file_load+0xc10>
<== ALWAYS TAKEN
4000fef8: a0 10 00 1d mov %i5, %l0
for (i = 0; i < obj->obj_num; ++i)
4000fefc: 10 bf ff 6a b 4000fca4 <rtems_rtl_rap_file_load+0xc14>
<== NOT EXECUTED
4000ff00: e2 06 20 84 ld [ %i0 + 0x84 ], %l1
<== NOT EXECUTED
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_OBJECT, detail);
4000ff04: 7f ff e9 71 call 4000a4c8 <rtems_rtl_alloc_del>
<== NOT EXECUTED
4000ff08: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
4000ff0c: b0 0d e0 ff and %l7, 0xff, %i0
<== NOT EXECUTED
4000ff10: 81 c7 e0 08 ret
<== NOT EXECUTED
4000ff14: 81 e8 00 00 restore
<== NOT EXECUTED
rap->strtable_size = 0;
4000ff18: 10 bf fe 7b b 4000f904 <rtems_rtl_rap_file_load+0x874>
<== NOT EXECUTED
4000ff1c: c0 27 bf f4 clr [ %fp + -12 ]
<== NOT EXECUTED
if (symname_size > (SYMNAME_BUFFER_SIZE - 1))
4000ff20: 18 80 00 0d bgu 4000ff54 <rtems_rtl_rap_file_load+0xec4>
<== NEVER TAKEN
4000ff24: d0 07 bf 88 ld [ %fp + -120 ], %o0
if (!rtems_rtl_obj_comp_read (rap->decomp, symname_buffer, symname_size))
4000ff28: 94 10 00 12 mov %l2, %o2
4000ff2c: 7f ff f5 14 call 4000d37c <rtems_rtl_obj_comp_read>
4000ff30: 92 10 00 1d mov %i5, %o1
4000ff34: 80 a2 20 00 cmp %o0, 0
4000ff38: 02 bf ff 24 be 4000fbc8 <rtems_rtl_rap_file_load+0xb38>
<== NEVER TAKEN
4000ff3c: 01 00 00 00 nop
symname_buffer[symname_size] = '\0';
4000ff40: c0 2f 40 12 clrb [ %i5 + %l2 ]
4000ff44: 10 bf ff 33 b 4000fc10 <rtems_rtl_rap_file_load+0xb80>
4000ff48: a4 10 00 1d mov %i5, %l2
const char* symname = NULL;
4000ff4c: 10 bf fe d3 b 4000fa98 <rtems_rtl_rap_file_load+0xa08>
<== NOT EXECUTED
4000ff50: a4 10 20 00 clr %l2
<== NOT EXECUTED
free (symname_buffer);
4000ff54: 7f ff dd 60 call 400074d4 <free>
<== NOT EXECUTED
4000ff58: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "reloc symbol too big");
4000ff5c: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
4000ff60: 13 10 00 c6 sethi %hi(0x40031800), %o1
<== NOT EXECUTED
4000ff64: 7f ff ef a2 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000ff68: 92 12 60 90 or %o1, 0x90, %o1 ! 40031890 <loaders+0x3a0>
<== NOT EXECUTED
return false;
4000ff6c: 10 bf fc 5f b 4000f0e8 <rtems_rtl_rap_file_load+0x58>
<== NOT EXECUTED
4000ff70: ae 10 20 00 clr %l7
<== NOT EXECUTED
4000ff7c <rtems_rtl_rap_file_sig>:
rtems_rtl_loader_format*
rtems_rtl_rap_file_sig (void)
{
return &rap_sig;
4000ff7c: 11 10 00 d3 sethi %hi(0x40034c00), %o0
<== NOT EXECUTED
}
4000ff80: 81 c3 e0 08 retl
<== NOT EXECUTED
4000ff84: 90 12 23 84 or %o0, 0x384, %o0 ! 40034f84 <rap_sig>
<== NOT EXECUTED
4000ff88 <rtems_rtl_strdup>:
#include <rtems/rtl/rtl-allocator.h>
#include "rtl-string.h"
char*
rtems_rtl_strdup (const char *s1)
{
4000ff88: 9d e3 bf a0 save %sp, -96, %sp
size_t len = strlen (s1);
4000ff8c: 40 00 33 34 call 4001cc5c <strlen>
4000ff90: 90 10 00 18 mov %i0, %o0
char* s2 = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_OBJECT, len + 1, false);
4000ff94: 94 10 20 00 clr %o2
4000ff98: 92 02 20 01 add %o0, 1, %o1
size_t len = strlen (s1);
4000ff9c: b8 10 00 08 mov %o0, %i4
char* s2 = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_OBJECT, len + 1, false);
4000ffa0: 7f ff e9 21 call 4000a424 <rtems_rtl_alloc_new>
4000ffa4: 90 10 20 00 clr %o0
if (s2)
4000ffa8: ba 92 20 00 orcc %o0, 0, %i5
4000ffac: 02 80 00 05 be 4000ffc0 <rtems_rtl_strdup+0x38>
<== NEVER TAKEN
4000ffb0: 94 10 00 1c mov %i4, %o2
{
memcpy (s2, s1, len);
4000ffb4: 40 00 2b 6c call 4001ad64 <memcpy>
4000ffb8: 92 10 00 18 mov %i0, %o1
s2[len] = '\0';
4000ffbc: c0 2f 40 1c clrb [ %i5 + %i4 ]
}
return s2;
}
4000ffc0: 81 c7 e0 08 ret
4000ffc4: 91 e8 00 1d restore %g0, %i5, %o0
400101c8 <rtems_rtl_symbol_global_add>:
{
400101c8: 9d e3 bf 98 save %sp, -104, %sp
while ((s < size) && (esyms[s] != 0))
400101cc: 80 a6 a0 00 cmp %i2, 0
400101d0: 02 80 00 97 be 4001042c <rtems_rtl_symbol_global_add+0x264>
<== NEVER TAKEN
400101d4: b8 10 20 00 clr %i4
400101d8: c2 0e 40 00 ldub [ %i1 ], %g1
400101dc: 80 a0 60 00 cmp %g1, 0
400101e0: 02 80 00 98 be 40010440 <rtems_rtl_symbol_global_add+0x278>
<== NEVER TAKEN
400101e4: 90 10 00 19 mov %i1, %o0
s = 0;
400101e8: 10 80 00 0b b 40010214 <rtems_rtl_symbol_global_add+0x4c>
400101ec: ba 10 20 00 clr %i5
if ((esyms[s + l] != '\0') || ((s + l) > size))
400101f0: 0a 80 00 10 bcs 40010230 <rtems_rtl_symbol_global_add+0x68>
<== NEVER TAKEN
400101f4: ba 00 60 05 add %g1, 5, %i5
while ((s < size) && (esyms[s] != 0))
400101f8: 80 a6 80 1d cmp %i2, %i5
400101fc: 08 80 00 15 bleu 40010250 <rtems_rtl_symbol_global_add+0x88>
<== NEVER TAKEN
40010200: b8 07 20 01 inc %i4
40010204: c4 0e 40 1d ldub [ %i1 + %i5 ], %g2
40010208: 80 a0 a0 00 cmp %g2, 0
4001020c: 02 80 00 11 be 40010250 <rtems_rtl_symbol_global_add+0x88>
40010210: 90 06 40 1d add %i1, %i5, %o0
int l = strlen ((char*) &esyms[s]);
40010214: 40 00 32 92 call 4001cc5c <strlen>
40010218: 01 00 00 00 nop
if ((esyms[s + l] != '\0') || ((s + l) > size))
4001021c: 82 02 00 1d add %o0, %i5, %g1
40010220: c4 0e 40 01 ldub [ %i1 + %g1 ], %g2
40010224: 80 a0 a0 00 cmp %g2, 0
40010228: 02 bf ff f2 be 400101f0 <rtems_rtl_symbol_global_add+0x28>
<== ALWAYS TAKEN
4001022c: 80 a6 80 01 cmp %i2, %g1
rtems_rtl_set_error (EINVAL, "invalid exported symbol table");
40010230: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
40010234: 13 10 00 c6 sethi %hi(0x40031800), %o1
<== NOT EXECUTED
return false;
40010238: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "invalid exported symbol table");
4001023c: 7f ff ee ec call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
40010240: 92 12 61 d8 or %o1, 0x1d8, %o1
<== NOT EXECUTED
}
40010244: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
40010248: 81 c7 e0 08 ret
<== NOT EXECUTED
4001024c: 81 e8 00 00 restore
<== NOT EXECUTED
40010250: 88 00 60 06 add %g1, 6, %g4
40010254: 86 00 60 07 add %g1, 7, %g3
40010258: 84 00 60 08 add %g1, 8, %g2
4001025c: 82 00 60 09 add %g1, 9, %g1
marker = esyms[s + 1];
40010260: fa 0e 40 04 ldub [ %i1 + %g4 ], %i5
marker |= esyms[s + 3];
40010264: c4 0e 40 02 ldub [ %i1 + %g2 ], %g2
marker |= esyms[s + 4];
40010268: c8 0e 40 01 ldub [ %i1 + %g1 ], %g4
marker |= esyms[s + 2];
4001026c: c6 0e 40 03 ldub [ %i1 + %g3 ], %g3
marker <<= 8;
40010270: 83 2f 60 08 sll %i5, 8, %g1
marker |= esyms[s + 2];
40010274: 82 10 c0 01 or %g3, %g1, %g1
marker <<= 8;
40010278: 83 28 60 08 sll %g1, 8, %g1
marker |= esyms[s + 3];
4001027c: 82 10 80 01 or %g2, %g1, %g1
if (marker != 0xdeadbeefUL)
40010280: 05 37 ab 6f sethi %hi(0xdeadbc00), %g2
marker <<= 8;
40010284: 83 28 60 08 sll %g1, 8, %g1
if (marker != 0xdeadbeefUL)
40010288: 84 10 a2 ef or %g2, 0x2ef, %g2
marker |= esyms[s + 4];
4001028c: 82 11 00 01 or %g4, %g1, %g1
if (marker != 0xdeadbeefUL)
40010290: 80 a0 40 02 cmp %g1, %g2
40010294: 02 80 00 09 be 400102b8 <rtems_rtl_symbol_global_add+0xf0>
<== ALWAYS TAKEN
40010298: 90 10 20 0c mov 0xc, %o0
rtems_rtl_set_error (ENOMEM, "invalid export symbol table");
4001029c: 13 10 00 c6 sethi %hi(0x40031800), %o1
<== NOT EXECUTED
return false;
400102a0: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (ENOMEM, "invalid export symbol table");
400102a4: 92 12 61 f8 or %o1, 0x1f8, %o1
<== NOT EXECUTED
400102a8: 7f ff ee d1 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
400102ac: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
}
400102b0: 81 c7 e0 08 ret
<== NOT EXECUTED
400102b4: 81 e8 00 00 restore
<== NOT EXECUTED
if (rtems_rtl_trace (RTEMS_RTL_TRACE_GLOBAL_SYM))
400102b8: 40 00 00 d3 call 40010604 <rtems_rtl_trace>
400102bc: 90 10 20 80 mov 0x80, %o0
400102c0: 80 a2 20 00 cmp %o0, 0
400102c4: 12 80 00 4c bne 400103f4 <rtems_rtl_symbol_global_add+0x22c>
400102c8: 92 10 00 1c mov %i4, %o1
obj->global_size = count * sizeof (rtems_rtl_obj_sym);
400102cc: 93 2f 20 02 sll %i4, 2, %o1
400102d0: 92 02 40 1c add %o1, %i4, %o1
400102d4: 93 2a 60 02 sll %o1, 2, %o1
400102d8: d2 26 20 4c st %o1, [ %i0 + 0x4c ]
obj->global_table = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_SYMBOL,
400102dc: 94 10 20 01 mov 1, %o2
400102e0: 7f ff e8 51 call 4000a424 <rtems_rtl_alloc_new>
400102e4: 90 10 20 01 mov 1, %o0
if (!obj->global_table)
400102e8: 80 a2 20 00 cmp %o0, 0
400102ec: 02 80 00 47 be 40010408 <rtems_rtl_symbol_global_add+0x240>
<== NEVER TAKEN
400102f0: d0 26 20 44 st %o0, [ %i0 + 0x44 ]
symbols = rtems_rtl_global_symbols ();
400102f4: 7f ff ef fe call 4000c2ec <rtems_rtl_global_symbols>
400102f8: 01 00 00 00 nop
while ((s < size) && (esyms[s] != 0))
400102fc: 80 a6 a0 00 cmp %i2, 0
symbols = rtems_rtl_global_symbols ();
40010300: a4 10 00 08 mov %o0, %l2
while ((s < size) && (esyms[s] != 0))
40010304: 02 80 00 2a be 400103ac <rtems_rtl_symbol_global_add+0x1e4>
<== NEVER TAKEN
40010308: f6 06 20 44 ld [ %i0 + 0x44 ], %i3
4001030c: c2 0e 40 00 ldub [ %i1 ], %g1
40010310: 80 a0 60 00 cmp %g1, 0
40010314: 22 80 00 27 be,a 400103b0 <rtems_rtl_symbol_global_add+0x1e8>
<== NEVER TAKEN
40010318: f8 26 20 48 st %i4, [ %i0 + 0x48 ]
<== NOT EXECUTED
printf ("rtl: esyms: %s -> %8p\n", sym->name, sym->value);
4001031c: 23 10 00 c6 sethi %hi(0x40031800), %l1
while ((s < size) && (esyms[s] != 0))
40010320: 90 10 00 19 mov %i1, %o0
s = 0;
40010324: ba 10 20 00 clr %i5
40010328: a0 07 bf fc add %fp, -4, %l0
printf ("rtl: esyms: %s -> %8p\n", sym->name, sym->value);
4001032c: a2 14 62 58 or %l1, 0x258, %l1
s += strlen (sym->name) + 1;
40010330: 40 00 32 4b call 4001cc5c <strlen>
40010334: d0 26 e0 08 st %o0, [ %i3 + 8 ]
for (b = 0; b < sizeof (void*); ++b, ++s)
40010338: 82 10 20 00 clr %g1
s += strlen (sym->name) + 1;
4001033c: ba 02 00 1d add %o0, %i5, %i5
40010340: 84 07 60 01 add %i5, 1, %g2
copy_voidp.data[b] = esyms[s];
40010344: c6 0e 40 02 ldub [ %i1 + %g2 ], %g3
40010348: c6 2c 00 01 stb %g3, [ %l0 + %g1 ]
for (b = 0; b < sizeof (void*); ++b, ++s)
4001034c: 82 00 60 01 inc %g1
40010350: 80 a0 60 04 cmp %g1, 4
40010354: 12 bf ff fc bne 40010344 <rtems_rtl_symbol_global_add+0x17c>
40010358: 84 00 a0 01 inc %g2
sym->value = copy_voidp.value;
4001035c: c2 07 bf fc ld [ %fp + -4 ], %g1
40010360: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
if (rtems_rtl_trace (RTEMS_RTL_TRACE_GLOBAL_SYM))
40010364: 90 10 20 80 mov 0x80, %o0
40010368: 40 00 00 a7 call 40010604 <rtems_rtl_trace>
4001036c: ba 07 60 05 add %i5, 5, %i5
40010370: 80 a2 20 00 cmp %o0, 0
40010374: 32 80 00 13 bne,a 400103c0 <rtems_rtl_symbol_global_add+0x1f8>
40010378: d4 06 e0 0c ld [ %i3 + 0xc ], %o2
if (rtems_rtl_symbol_global_find (sym->name) == NULL)
4001037c: 7f ff ff 5e call 400100f4 <rtems_rtl_symbol_global_find>
40010380: d0 06 e0 08 ld [ %i3 + 8 ], %o0
40010384: 80 a2 20 00 cmp %o0, 0
40010388: 02 80 00 17 be 400103e4 <rtems_rtl_symbol_global_add+0x21c>
4001038c: 92 10 00 1b mov %i3, %o1
while ((s < size) && (esyms[s] != 0))
40010390: 80 a6 80 1d cmp %i2, %i5
40010394: 08 80 00 06 bleu 400103ac <rtems_rtl_symbol_global_add+0x1e4>
<== NEVER TAKEN
40010398: b6 06 e0 14 add %i3, 0x14, %i3
4001039c: c2 0e 40 1d ldub [ %i1 + %i5 ], %g1
400103a0: 80 a0 60 00 cmp %g1, 0
400103a4: 12 bf ff e3 bne 40010330 <rtems_rtl_symbol_global_add+0x168>
400103a8: 90 06 40 1d add %i1, %i5, %o0
obj->global_syms = count;
400103ac: f8 26 20 48 st %i4, [ %i0 + 0x48 ]
return true;
400103b0: b0 10 20 01 mov 1, %i0
}
400103b4: b0 0e 20 01 and %i0, 1, %i0
400103b8: 81 c7 e0 08 ret
400103bc: 81 e8 00 00 restore
printf ("rtl: esyms: %s -> %8p\n", sym->name, sym->value);
400103c0: d2 06 e0 08 ld [ %i3 + 8 ], %o1
400103c4: 40 00 21 61 call 40018948 <__wrap_printf>
400103c8: 90 10 00 11 mov %l1, %o0
if (rtems_rtl_symbol_global_find (sym->name) == NULL)
400103cc: 7f ff ff 4a call 400100f4 <rtems_rtl_symbol_global_find>
400103d0: d0 06 e0 08 ld [ %i3 + 8 ], %o0
400103d4: 80 a2 20 00 cmp %o0, 0
400103d8: 32 bf ff ef bne,a 40010394 <rtems_rtl_symbol_global_add+0x1cc>
400103dc: 80 a6 80 1d cmp %i2, %i5
rtems_rtl_symbol_global_insert (symbols, sym);
400103e0: 92 10 00 1b mov %i3, %o1
400103e4: 7f ff fe f9 call 4000ffc8 <rtems_rtl_symbol_global_insert>
400103e8: 90 10 00 12 mov %l2, %o0
while ((s < size) && (esyms[s] != 0))
400103ec: 10 bf ff ea b 40010394 <rtems_rtl_symbol_global_add+0x1cc>
400103f0: 80 a6 80 1d cmp %i2, %i5
printf ("rtl: global symbol add: %zi\n", count);
400103f4: 11 10 00 c6 sethi %hi(0x40031800), %o0
400103f8: 40 00 21 54 call 40018948 <__wrap_printf>
400103fc: 90 12 22 18 or %o0, 0x218, %o0 ! 40031a18 <rap_sections+0x9c>
obj->global_size = count * sizeof (rtems_rtl_obj_sym);
40010400: 10 bf ff b4 b 400102d0 <rtems_rtl_symbol_global_add+0x108>
40010404: 93 2f 20 02 sll %i4, 2, %o1
obj->global_size = 0;
40010408: c0 26 20 4c clr [ %i0 + 0x4c ]
<== NOT EXECUTED
rtems_rtl_set_error (ENOMEM, "no memory for global symbols");
4001040c: 90 10 20 0c mov 0xc, %o0
<== NOT EXECUTED
40010410: 13 10 00 c6 sethi %hi(0x40031800), %o1
<== NOT EXECUTED
return false;
40010414: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (ENOMEM, "no memory for global symbols");
40010418: 7f ff ee 75 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4001041c: 92 12 62 38 or %o1, 0x238, %o1
<== NOT EXECUTED
40010420: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
40010424: 81 c7 e0 08 ret
<== NOT EXECUTED
40010428: 81 e8 00 00 restore
<== NOT EXECUTED
while ((s < size) && (esyms[s] != 0))
4001042c: 82 10 20 04 mov 4, %g1
<== NOT EXECUTED
40010430: 84 10 20 03 mov 3, %g2
<== NOT EXECUTED
40010434: 86 10 20 02 mov 2, %g3
<== NOT EXECUTED
40010438: 10 bf ff 8a b 40010260 <rtems_rtl_symbol_global_add+0x98>
<== NOT EXECUTED
4001043c: 88 10 20 01 mov 1, %g4
<== NOT EXECUTED
40010440: 82 10 20 04 mov 4, %g1
<== NOT EXECUTED
40010444: 84 10 20 03 mov 3, %g2
<== NOT EXECUTED
40010448: 86 10 20 02 mov 2, %g3
<== NOT EXECUTED
4001044c: 88 10 20 01 mov 1, %g4
<== NOT EXECUTED
count = 0;
40010450: 10 bf ff 84 b 40010260 <rtems_rtl_symbol_global_add+0x98>
<== NOT EXECUTED
40010454: b8 10 20 00 clr %i4
<== NOT EXECUTED
400100f4 <rtems_rtl_symbol_global_find>:
return true;
}
rtems_rtl_obj_sym*
rtems_rtl_symbol_global_find (const char* name)
{
400100f4: 9d e3 bf a0 save %sp, -96, %sp
rtems_rtl_symbols* symbols;
uint_fast32_t hash;
rtems_chain_control* bucket;
rtems_chain_node* node;
symbols = rtems_rtl_global_symbols ();
400100f8: 7f ff f0 7d call 4000c2ec <rtems_rtl_global_symbols>
400100fc: 01 00 00 00 nop
for (c = *s; c != '\0'; c = *++s)
40010100: c4 0e 00 00 ldub [ %i0 ], %g2
40010104: 80 a0 a0 00 cmp %g2, 0
40010108: 02 80 00 2d be 400101bc <rtems_rtl_symbol_global_find+0xc8>
<== NEVER TAKEN
4001010c: 86 10 00 18 mov %i0, %g3
uint_fast32_t h = 5381;
40010110: 03 00 00 05 sethi %hi(0x1400), %g1
40010114: 82 10 61 05 or %g1, 0x105, %g1 ! 1505 <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0x13b5>
h = h * 33 + c;
40010118: 89 28 60 05 sll %g1, 5, %g4
for (c = *s; c != '\0'; c = *++s)
4001011c: 86 00 e0 01 inc %g3
h = h * 33 + c;
40010120: 82 01 00 01 add %g4, %g1, %g1
40010124: 82 00 80 01 add %g2, %g1, %g1
for (c = *s; c != '\0'; c = *++s)
40010128: c4 08 c0 00 ldub [ %g3 ], %g2
4001012c: 80 a0 a0 00 cmp %g2, 0
40010130: 12 bf ff fb bne 4001011c <rtems_rtl_symbol_global_find+0x28>
40010134: 89 28 60 05 sll %g1, 5, %g4
hash = rtems_rtl_symbol_hash (name);
bucket = &symbols->buckets[hash % symbols->nbuckets];
40010138: c6 02 20 04 ld [ %o0 + 4 ], %g3
4001013c: f8 02 00 00 ld [ %o0 ], %i4
40010140: 81 80 20 00 wr %g0, %y
40010144: 01 00 00 00 nop
40010148: 01 00 00 00 nop
4001014c: 01 00 00 00 nop
40010150: 84 70 40 03 udiv %g1, %g3, %g2
40010154: 84 58 80 03 smul %g2, %g3, %g2
40010158: 82 20 40 02 sub %g1, %g2, %g1
4001015c: 85 28 60 01 sll %g1, 1, %g2
40010160: 82 00 80 01 add %g2, %g1, %g1
40010164: 83 28 60 02 sll %g1, 2, %g1
return _Chain_Immutable_head( the_chain )->next;
40010168: fa 07 00 01 ld [ %i4 + %g1 ], %i5
4001016c: b8 07 00 01 add %i4, %g1, %i4
return &the_chain->Tail.Node;
40010170: b8 07 20 04 add %i4, 4, %i4
node = rtems_chain_first (bucket);
while (!rtems_chain_is_tail (bucket, node))
40010174: 80 a7 40 1c cmp %i5, %i4
40010178: 32 80 00 08 bne,a 40010198 <rtems_rtl_symbol_global_find+0xa4>
4001017c: d2 07 60 08 ld [ %i5 + 8 ], %o1
if (strcmp (name, sym->name) == 0)
return sym;
node = rtems_chain_next (node);
}
return NULL;
40010180: 10 80 00 0d b 400101b4 <rtems_rtl_symbol_global_find+0xc0>
40010184: ba 10 20 00 clr %i5
while (!rtems_chain_is_tail (bucket, node))
40010188: 80 a7 40 1c cmp %i5, %i4
4001018c: 22 80 00 0a be,a 400101b4 <rtems_rtl_symbol_global_find+0xc0>
40010190: ba 10 20 00 clr %i5
if (strcmp (name, sym->name) == 0)
40010194: d2 07 60 08 ld [ %i5 + 8 ], %o1
40010198: 40 00 30 84 call 4001c3a8 <strcmp>
4001019c: 90 10 00 18 mov %i0, %o0
400101a0: 80 a2 20 00 cmp %o0, 0
400101a4: 32 bf ff f9 bne,a 40010188 <rtems_rtl_symbol_global_find+0x94>
400101a8: fa 07 40 00 ld [ %i5 ], %i5
}
400101ac: 81 c7 e0 08 ret
400101b0: 91 e8 00 1d restore %g0, %i5, %o0
400101b4: 81 c7 e0 08 ret
400101b8: 91 e8 00 1d restore %g0, %i5, %o0
uint_fast32_t h = 5381;
400101bc: 03 00 00 05 sethi %hi(0x1400), %g1
<== NOT EXECUTED
400101c0: 10 bf ff de b 40010138 <rtems_rtl_symbol_global_find+0x44>
<== NOT EXECUTED
400101c4: 82 10 61 05 or %g1, 0x105, %g1 ! 1505 <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0x13b5>
<== NOT EXECUTED
400104ec <rtems_rtl_symbol_obj_add>:
void
rtems_rtl_symbol_obj_add (rtems_rtl_obj* obj)
{
400104ec: 9d e3 bf a0 save %sp, -96, %sp
rtems_rtl_symbols* symbols;
rtems_rtl_obj_sym* sym;
size_t s;
symbols = rtems_rtl_global_symbols ();
400104f0: 7f ff ef 7f call 4000c2ec <rtems_rtl_global_symbols>
400104f4: 01 00 00 00 nop
for (s = 0, sym = obj->global_table; s < obj->global_syms; ++s, ++sym)
400104f8: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
symbols = rtems_rtl_global_symbols ();
400104fc: b6 10 00 08 mov %o0, %i3
for (s = 0, sym = obj->global_table; s < obj->global_syms; ++s, ++sym)
40010500: 80 a0 60 00 cmp %g1, 0
40010504: 02 80 00 0b be 40010530 <rtems_rtl_symbol_obj_add+0x44>
<== NEVER TAKEN
40010508: fa 06 20 44 ld [ %i0 + 0x44 ], %i5
4001050c: b8 10 20 00 clr %i4
rtems_rtl_symbol_global_insert (symbols, sym);
40010510: 92 10 00 1d mov %i5, %o1
40010514: 7f ff fe ad call 4000ffc8 <rtems_rtl_symbol_global_insert>
40010518: 90 10 00 1b mov %i3, %o0
for (s = 0, sym = obj->global_table; s < obj->global_syms; ++s, ++sym)
4001051c: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
40010520: b8 07 20 01 inc %i4
40010524: 80 a0 40 1c cmp %g1, %i4
40010528: 18 bf ff fa bgu 40010510 <rtems_rtl_symbol_obj_add+0x24>
4001052c: ba 07 60 14 add %i5, 0x14, %i5
}
40010530: 81 c7 e0 08 ret
40010534: 81 e8 00 00 restore
40010568 <rtems_rtl_symbol_obj_erase>:
void
rtems_rtl_symbol_obj_erase (rtems_rtl_obj* obj)
{
40010568: 9d e3 bf a0 save %sp, -96, %sp
if (obj->local_table)
4001056c: d2 06 20 38 ld [ %i0 + 0x38 ], %o1
40010570: 80 a2 60 00 cmp %o1, 0
40010574: 22 80 00 08 be,a 40010594 <rtems_rtl_symbol_obj_erase+0x2c>
<== ALWAYS TAKEN
40010578: fa 06 20 44 ld [ %i0 + 0x44 ], %i5
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_SYMBOL, obj->local_table);
4001057c: 7f ff e7 d3 call 4000a4c8 <rtems_rtl_alloc_del>
<== NOT EXECUTED
40010580: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
obj->local_table = NULL;
40010584: c0 26 20 38 clr [ %i0 + 0x38 ]
<== NOT EXECUTED
obj->local_size = 0;
40010588: c0 26 20 40 clr [ %i0 + 0x40 ]
<== NOT EXECUTED
obj->local_syms = 0;
4001058c: c0 26 20 3c clr [ %i0 + 0x3c ]
<== NOT EXECUTED
rtems_rtl_symbol_obj_erase_local (obj);
if (obj->global_table)
40010590: fa 06 20 44 ld [ %i0 + 0x44 ], %i5
<== NOT EXECUTED
40010594: 80 a7 60 00 cmp %i5, 0
40010598: 02 80 00 19 be 400105fc <rtems_rtl_symbol_obj_erase+0x94>
<== NEVER TAKEN
4001059c: 01 00 00 00 nop
{
rtems_rtl_obj_sym* sym;
size_t s;
for (s = 0, sym = obj->global_table; s < obj->global_syms; ++s, ++sym)
400105a0: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
400105a4: 80 a0 a0 00 cmp %g2, 0
400105a8: 02 80 00 10 be 400105e8 <rtems_rtl_symbol_obj_erase+0x80>
<== NEVER TAKEN
400105ac: 92 10 00 1d mov %i5, %o1
400105b0: b8 10 20 00 clr %i4
if (!rtems_chain_is_node_off_chain (&sym->node))
400105b4: c2 07 40 00 ld [ %i5 ], %g1
400105b8: 80 a0 60 00 cmp %g1, 0
400105bc: 02 80 00 05 be 400105d0 <rtems_rtl_symbol_obj_erase+0x68>
<== NEVER TAKEN
400105c0: 90 10 00 1d mov %i5, %o0
rtems_chain_extract (&sym->node);
400105c4: 40 00 06 e4 call 40012154 <rtems_chain_extract>
400105c8: 01 00 00 00 nop
400105cc: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
for (s = 0, sym = obj->global_table; s < obj->global_syms; ++s, ++sym)
400105d0: b8 07 20 01 inc %i4
400105d4: 80 a0 80 1c cmp %g2, %i4
400105d8: 18 bf ff f7 bgu 400105b4 <rtems_rtl_symbol_obj_erase+0x4c>
400105dc: ba 07 60 14 add %i5, 0x14, %i5
400105e0: fa 06 20 44 ld [ %i0 + 0x44 ], %i5
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_SYMBOL, obj->global_table);
400105e4: 92 10 00 1d mov %i5, %o1
400105e8: 7f ff e7 b8 call 4000a4c8 <rtems_rtl_alloc_del>
400105ec: 90 10 20 01 mov 1, %o0
obj->global_table = NULL;
400105f0: c0 26 20 44 clr [ %i0 + 0x44 ]
obj->global_size = 0;
400105f4: c0 26 20 4c clr [ %i0 + 0x4c ]
obj->global_syms = 0;
400105f8: c0 26 20 48 clr [ %i0 + 0x48 ]
}
}
400105fc: 81 c7 e0 08 ret
40010600: 81 e8 00 00 restore
40010458 <rtems_rtl_symbol_obj_find>:
rtems_rtl_obj_sym*
rtems_rtl_symbol_obj_find (rtems_rtl_obj* obj, const char* name)
{
40010458: 9d e3 bf a0 save %sp, -96, %sp
size_t s;
/*
* Check the object file's symbols first. If not found search the
* global symbol table.
*/
if (obj->local_syms)
4001045c: f6 06 20 3c ld [ %i0 + 0x3c ], %i3
40010460: 80 a6 e0 00 cmp %i3, 0
40010464: 22 80 00 11 be,a 400104a8 <rtems_rtl_symbol_obj_find+0x50>
40010468: f6 06 20 48 ld [ %i0 + 0x48 ], %i3
{
for (s = 0, sym = obj->local_table; s < obj->local_syms; ++s, ++sym)
4001046c: fa 06 20 38 ld [ %i0 + 0x38 ], %i5
40010470: 10 80 00 05 b 40010484 <rtems_rtl_symbol_obj_find+0x2c>
40010474: b8 10 20 00 clr %i4
40010478: 80 a6 c0 1c cmp %i3, %i4
4001047c: 02 80 00 0a be 400104a4 <rtems_rtl_symbol_obj_find+0x4c>
<== ALWAYS TAKEN
40010480: ba 07 60 14 add %i5, 0x14, %i5
if (strcmp (name, sym->name) == 0)
40010484: d2 07 60 08 ld [ %i5 + 8 ], %o1
40010488: 40 00 2f c8 call 4001c3a8 <strcmp>
4001048c: 90 10 00 19 mov %i1, %o0
40010490: 80 a2 20 00 cmp %o0, 0
40010494: 12 bf ff f9 bne 40010478 <rtems_rtl_symbol_obj_find+0x20>
<== ALWAYS TAKEN
40010498: b8 07 20 01 inc %i4
for (s = 0, sym = obj->global_table; s < obj->global_syms; ++s, ++sym)
if (strcmp (name, sym->name) == 0)
return sym;
}
return rtems_rtl_symbol_global_find (name);
}
4001049c: 81 c7 e0 08 ret
400104a0: 91 e8 00 1d restore %g0, %i5, %o0
if (obj->global_syms)
400104a4: f6 06 20 48 ld [ %i0 + 0x48 ], %i3
400104a8: 80 a6 e0 00 cmp %i3, 0
400104ac: 02 80 00 0e be 400104e4 <rtems_rtl_symbol_obj_find+0x8c>
<== NEVER TAKEN
400104b0: b8 10 20 00 clr %i4
for (s = 0, sym = obj->global_table; s < obj->global_syms; ++s, ++sym)
400104b4: 10 80 00 05 b 400104c8 <rtems_rtl_symbol_obj_find+0x70>
400104b8: fa 06 20 44 ld [ %i0 + 0x44 ], %i5
400104bc: 80 a6 c0 1c cmp %i3, %i4
400104c0: 02 80 00 09 be 400104e4 <rtems_rtl_symbol_obj_find+0x8c>
400104c4: ba 07 60 14 add %i5, 0x14, %i5
if (strcmp (name, sym->name) == 0)
400104c8: d2 07 60 08 ld [ %i5 + 8 ], %o1
400104cc: 40 00 2f b7 call 4001c3a8 <strcmp>
400104d0: 90 10 00 19 mov %i1, %o0
400104d4: 80 a2 20 00 cmp %o0, 0
400104d8: 32 bf ff f9 bne,a 400104bc <rtems_rtl_symbol_obj_find+0x64>
400104dc: b8 07 20 01 inc %i4
400104e0: 30 bf ff ef b,a 4001049c <rtems_rtl_symbol_obj_find+0x44>
return rtems_rtl_symbol_global_find (name);
400104e4: 7f ff ff 04 call 400100f4 <rtems_rtl_symbol_global_find>
400104e8: 91 e8 00 19 restore %g0, %i1, %o0
400100e0 <rtems_rtl_symbol_table_close>:
void
rtems_rtl_symbol_table_close (rtems_rtl_symbols* symbols)
{
rtems_rtl_alloc_del (RTEMS_RTL_ALLOC_SYMBOL, symbols->buckets);
400100e0: d2 02 00 00 ld [ %o0 ], %o1
<== NOT EXECUTED
400100e4: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
400100e8: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
400100ec: 7f ff e8 f7 call 4000a4c8 <rtems_rtl_alloc_del>
<== NOT EXECUTED
400100f0: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40010040 <rtems_rtl_symbol_table_open>:
}
bool
rtems_rtl_symbol_table_open (rtems_rtl_symbols* symbols,
size_t buckets)
{
40010040: 9d e3 bf a0 save %sp, -96, %sp
symbols->buckets = rtems_rtl_alloc_new (RTEMS_RTL_ALLOC_SYMBOL,
40010044: 94 10 20 01 mov 1, %o2
40010048: bb 2e 60 01 sll %i1, 1, %i5
4001004c: 90 10 20 01 mov 1, %o0
40010050: ba 07 40 19 add %i5, %i1, %i5
40010054: bb 2f 60 02 sll %i5, 2, %i5
40010058: 7f ff e8 f3 call 4000a424 <rtems_rtl_alloc_new>
4001005c: 92 10 00 1d mov %i5, %o1
buckets * sizeof (rtems_chain_control),
true);
if (!symbols->buckets)
40010060: 80 a2 20 00 cmp %o0, 0
40010064: 02 80 00 17 be 400100c0 <rtems_rtl_symbol_table_open+0x80>
<== NEVER TAKEN
40010068: d0 26 00 00 st %o0, [ %i0 ]
{
rtems_rtl_set_error (ENOMEM, "no memory for global symbol table");
return false;
}
symbols->nbuckets = buckets;
for (buckets = 0; buckets < symbols->nbuckets; ++buckets)
4001006c: 80 a6 60 00 cmp %i1, 0
40010070: 02 80 00 0c be 400100a0 <rtems_rtl_symbol_table_open+0x60>
<== NEVER TAKEN
40010074: f2 26 20 04 st %i1, [ %i0 + 4 ]
40010078: ba 07 60 04 add %i5, 4, %i5
4001007c: 82 02 20 04 add %o0, 4, %g1
40010080: 90 02 00 1d add %o0, %i5, %o0
head->previous = NULL;
40010084: c0 20 40 00 clr [ %g1 ]
tail->previous = head;
40010088: 84 00 7f fc add %g1, -4, %g2
head->next = tail;
4001008c: c2 20 7f fc st %g1, [ %g1 + -4 ]
40010090: 82 00 60 0c add %g1, 0xc, %g1
40010094: 80 a0 40 08 cmp %g1, %o0
40010098: 12 bf ff fb bne 40010084 <rtems_rtl_symbol_table_open+0x44>
4001009c: c4 20 7f f8 st %g2, [ %g1 + -8 ]
rtems_chain_initialize_empty (&symbols->buckets[buckets]);
rtems_rtl_symbol_global_insert (symbols, &global_sym_add);
400100a0: 90 10 00 18 mov %i0, %o0
400100a4: 13 10 00 d3 sethi %hi(0x40034c00), %o1
return true;
400100a8: b0 10 20 01 mov 1, %i0
rtems_rtl_symbol_global_insert (symbols, &global_sym_add);
400100ac: 92 12 63 8c or %o1, 0x38c, %o1
400100b0: 7f ff ff c6 call 4000ffc8 <rtems_rtl_symbol_global_insert>
400100b4: b0 0e 20 01 and %i0, 1, %i0
}
400100b8: 81 c7 e0 08 ret
400100bc: 81 e8 00 00 restore
rtems_rtl_set_error (ENOMEM, "no memory for global symbol table");
400100c0: 90 10 20 0c mov 0xc, %o0
<== NOT EXECUTED
400100c4: 13 10 00 c6 sethi %hi(0x40031800), %o1
<== NOT EXECUTED
return false;
400100c8: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (ENOMEM, "no memory for global symbol table");
400100cc: 92 12 61 b0 or %o1, 0x1b0, %o1
<== NOT EXECUTED
400100d0: 7f ff ef 47 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
400100d4: b0 0e 20 01 and %i0, 1, %i0
<== NOT EXECUTED
}
400100d8: 81 c7 e0 08 ret
<== NOT EXECUTED
400100dc: 81 e8 00 00 restore
<== NOT EXECUTED
4000caf0 <rtems_rtl_unload_object>:
{
4000caf0: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rtl_trace (RTEMS_RTL_TRACE_UNLOAD))
4000caf4: 40 00 0e c4 call 40010604 <rtems_rtl_trace>
4000caf8: 90 10 20 08 mov 8, %o0
4000cafc: 80 a2 20 00 cmp %o0, 0
4000cb00: 32 80 00 27 bne,a 4000cb9c <rtems_rtl_unload_object+0xac>
4000cb04: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
if ((obj->flags & RTEMS_RTL_OBJ_LOCKED) == RTEMS_RTL_OBJ_LOCKED)
4000cb08: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000cb0c: 80 88 60 01 btst 1, %g1
4000cb10: 12 80 00 2b bne 4000cbbc <rtems_rtl_unload_object+0xcc>
<== NEVER TAKEN
4000cb14: 90 10 20 16 mov 0x16, %o0
if (obj->users > 0)
4000cb18: c4 06 20 0c ld [ %i0 + 0xc ], %g2
4000cb1c: 80 a0 a0 00 cmp %g2, 0
4000cb20: 22 80 00 0b be,a 4000cb4c <rtems_rtl_unload_object+0x5c>
<== NEVER TAKEN
4000cb24: 82 10 60 01 or %g1, 1, %g1
<== NOT EXECUTED
--obj->users;
4000cb28: 84 00 bf ff add %g2, -1, %g2
if (obj->users == 0)
4000cb2c: 80 a0 a0 00 cmp %g2, 0
4000cb30: 02 80 00 06 be 4000cb48 <rtems_rtl_unload_object+0x58>
<== ALWAYS TAKEN
4000cb34: c4 26 20 0c st %g2, [ %i0 + 0xc ]
bool ok = true;
4000cb38: ba 10 20 01 mov 1, %i5
<== NOT EXECUTED
}
4000cb3c: b0 0f 60 ff and %i5, 0xff, %i0
<== NOT EXECUTED
4000cb40: 81 c7 e0 08 ret
<== NOT EXECUTED
4000cb44: 81 e8 00 00 restore
<== NOT EXECUTED
obj->flags |= RTEMS_RTL_OBJ_LOCKED;
4000cb48: 82 10 60 01 or %g1, 1, %g1
4000cb4c: c2 26 20 08 st %g1, [ %i0 + 8 ]
rtems_recursive_mutex_unlock (&rtl->lock);
4000cb50: 03 10 00 d8 sethi %hi(0x40036000), %g1
4000cb54: 40 00 1e b3 call 40014620 <_Mutex_recursive_Release>
4000cb58: d0 00 61 e4 ld [ %g1 + 0x1e4 ], %o0 ! 400361e4 <rtl>
rtems_rtl_obj_run_dtors (obj);
4000cb5c: 40 00 08 3b call 4000ec48 <rtems_rtl_obj_run_dtors>
4000cb60: 90 10 00 18 mov %i0, %o0
rtems_rtl_lock ();
4000cb64: 7f ff fe 34 call 4000c434 <rtems_rtl_lock>
4000cb68: 01 00 00 00 nop
obj->flags &= ~RTEMS_RTL_OBJ_LOCKED;
4000cb6c: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000cb70: 82 08 7f fe and %g1, -2, %g1
4000cb74: c2 26 20 08 st %g1, [ %i0 + 8 ]
ok = rtems_rtl_obj_unload (obj);
4000cb78: 40 00 08 8e call 4000edb0 <rtems_rtl_obj_unload>
4000cb7c: 90 10 00 18 mov %i0, %o0
4000cb80: ba 10 00 08 mov %o0, %i5
rtems_rtl_obj_free (obj);
4000cb84: 40 00 03 ef call 4000db40 <rtems_rtl_obj_free>
4000cb88: 90 10 00 18 mov %i0, %o0
rtems_rtl_obj_caches_flush ();
4000cb8c: 7f ff fe 0e call 4000c3c4 <rtems_rtl_obj_caches_flush>
4000cb90: b0 0f 60 ff and %i5, 0xff, %i0
}
4000cb94: 81 c7 e0 08 ret
4000cb98: 81 e8 00 00 restore
printf ("rtl: unloading '%s'\n", rtems_rtl_obj_fname (obj));
4000cb9c: 11 10 00 c3 sethi %hi(0x40030c00), %o0
4000cba0: 40 00 2f 6a call 40018948 <__wrap_printf>
4000cba4: 90 12 22 28 or %o0, 0x228, %o0 ! 40030e28 <reloc_target_flags+0xc0>
if ((obj->flags & RTEMS_RTL_OBJ_LOCKED) == RTEMS_RTL_OBJ_LOCKED)
4000cba8: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000cbac: 80 88 60 01 btst 1, %g1
4000cbb0: 22 bf ff db be,a 4000cb1c <rtems_rtl_unload_object+0x2c>
<== ALWAYS TAKEN
4000cbb4: c4 06 20 0c ld [ %i0 + 0xc ], %g2
rtems_rtl_set_error (EINVAL, "cannot unload when locked");
4000cbb8: 90 10 20 16 mov 0x16, %o0
<== NOT EXECUTED
return false;
4000cbbc: ba 10 20 00 clr %i5
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "cannot unload when locked");
4000cbc0: 13 10 00 c3 sethi %hi(0x40030c00), %o1
<== NOT EXECUTED
}
4000cbc4: b0 0f 60 ff and %i5, 0xff, %i0
<== NOT EXECUTED
rtems_rtl_set_error (EINVAL, "cannot unload when locked");
4000cbc8: 7f ff fc 89 call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000cbcc: 92 12 62 40 or %o1, 0x240, %o1
<== NOT EXECUTED
}
4000cbd0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000cbd4: 81 e8 00 00 restore
<== NOT EXECUTED
400109e8 <rtems_rtl_unresolved_add>:
rtems_rtl_unresolved_add (rtems_rtl_obj* obj,
const uint16_t flags,
const char* name,
const uint16_t sect,
const rtems_rtl_word* rel)
{
400109e8: 9d e3 bf a0 save %sp, -96, %sp
rtems_rtl_unresolv_block* block;
rtems_rtl_unresolv_rec* rec;
int name_index;
size_t name_recs;
if (rtems_rtl_trace (RTEMS_RTL_TRACE_UNRESOLVED))
400109ec: 7f ff ff 06 call 40010604 <rtems_rtl_trace>
400109f0: 90 10 24 00 mov 0x400, %o0
400109f4: 80 a2 20 00 cmp %o0, 0
400109f8: 12 80 00 8a bne 40010c20 <rtems_rtl_unresolved_add+0x238>
<== NEVER TAKEN
400109fc: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
printf ("rtl: unresolv: add: %s(s:%d) -> %s\n",
rtems_rtl_obj_oname (obj), sect, name);
unresolved = rtems_rtl_unresolved_unprotected ();
40010a00: 7f ff ee 48 call 4000c320 <rtems_rtl_unresolved_unprotected>
40010a04: 01 00 00 00 nop
if (!unresolved)
40010a08: ac 92 20 00 orcc %o0, 0, %l6
40010a0c: 02 80 00 7d be 40010c00 <rtems_rtl_unresolved_add+0x218>
<== NEVER TAKEN
40010a10: ba 05 a0 0c add %l6, 0xc, %i5
return _Chain_Immutable_head( the_chain )->next;
40010a14: f2 05 a0 08 ld [ %l6 + 8 ], %i1
/*
* Find the first block with a spare record.
*/
node = rtems_chain_first (&unresolved->blocks);
block = NULL;
while (!rtems_chain_is_tail (&unresolved->blocks, node))
40010a18: 80 a6 40 1d cmp %i1, %i5
40010a1c: 02 80 00 0f be 40010a58 <rtems_rtl_unresolved_add+0x70>
40010a20: 01 00 00 00 nop
{
block = (rtems_rtl_unresolv_block*) node;
if (block->recs < unresolved->block_recs)
40010a24: c6 05 a0 04 ld [ %l6 + 4 ], %g3
40010a28: c2 06 60 08 ld [ %i1 + 8 ], %g1
40010a2c: 80 a0 40 03 cmp %g1, %g3
40010a30: 1a 80 00 06 bcc 40010a48 <rtems_rtl_unresolved_add+0x60>
<== NEVER TAKEN
40010a34: a8 10 00 19 mov %i1, %l4
40010a38: 30 80 00 76 b,a 40010c10 <rtems_rtl_unresolved_add+0x228>
40010a3c: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
40010a40: 0a 80 00 74 bcs 40010c10 <rtems_rtl_unresolved_add+0x228>
<== NOT EXECUTED
40010a44: 01 00 00 00 nop
<== NOT EXECUTED
40010a48: e8 05 00 00 ld [ %l4 ], %l4
<== NOT EXECUTED
while (!rtems_chain_is_tail (&unresolved->blocks, node))
40010a4c: 80 a5 00 1d cmp %l4, %i5
<== NOT EXECUTED
40010a50: 32 bf ff fb bne,a 40010a3c <rtems_rtl_unresolved_add+0x54>
<== NOT EXECUTED
40010a54: c2 05 20 08 ld [ %l4 + 8 ], %g1
<== NOT EXECUTED
/*
* No blocks with any spare records, allocate a new block.
*/
if (!block)
{
block = rtems_rtl_unresolved_block_alloc (unresolved);
40010a58: 7f ff ff 07 call 40010674 <rtems_rtl_unresolved_block_alloc>
40010a5c: 90 10 00 16 mov %l6, %o0
if (!block)
40010a60: a8 92 20 00 orcc %o0, 0, %l4
40010a64: 22 80 00 68 be,a 40010c04 <rtems_rtl_unresolved_add+0x21c>
<== NEVER TAKEN
40010a68: b0 10 20 00 clr %i0
<== NOT EXECUTED
size_t length = strlen (name);
40010a6c: 40 00 30 7c call 4001cc5c <strlen>
40010a70: 90 10 00 1a mov %i2, %o0
40010a74: f2 05 a0 08 ld [ %l6 + 8 ], %i1
while (!rtems_chain_is_tail (&unresolved->blocks, node))
40010a78: 80 a6 40 1d cmp %i1, %i5
40010a7c: 02 80 00 94 be 40010ccc <rtems_rtl_unresolved_add+0x2e4>
<== NEVER TAKEN
40010a80: aa 10 00 08 mov %o0, %l5
int index = (rec - &block->rec) / sizeof (rec);
40010a84: 25 2d b6 db sethi %hi(0xb6db6c00), %l2
if (block->recs < unresolved->block_recs)
40010a88: a6 10 20 01 mov 1, %l3
int index = (rec - &block->rec) / sizeof (rec);
40010a8c: a4 14 a1 b7 or %l2, 0x1b7, %l2
return !rec || (index >= block->recs) || (rec->type == rtems_rtl_unresolved_empty);
40010a90: a2 86 60 0c addcc %i1, 0xc, %l1
40010a94: 22 80 00 0b be,a 40010ac0 <rtems_rtl_unresolved_add+0xd8>
<== NEVER TAKEN
40010a98: f2 06 40 00 ld [ %i1 ], %i1
<== NOT EXECUTED
40010a9c: e0 06 60 08 ld [ %i1 + 8 ], %l0
40010aa0: 80 a4 20 00 cmp %l0, 0
40010aa4: 22 80 00 07 be,a 40010ac0 <rtems_rtl_unresolved_add+0xd8>
40010aa8: f2 06 40 00 ld [ %i1 ], %i1
40010aac: c2 06 60 0c ld [ %i1 + 0xc ], %g1
40010ab0: 80 a0 60 00 cmp %g1, 0
40010ab4: 12 80 00 15 bne 40010b08 <rtems_rtl_unresolved_add+0x120>
<== ALWAYS TAKEN
40010ab8: ae 10 00 11 mov %l1, %l7
40010abc: f2 06 40 00 ld [ %i1 ], %i1
<== NOT EXECUTED
while (!rtems_chain_is_tail (&unresolved->blocks, node))
40010ac0: 80 a6 40 1d cmp %i1, %i5
40010ac4: 32 bf ff f4 bne,a 40010a94 <rtems_rtl_unresolved_add+0xac>
<== NEVER TAKEN
40010ac8: a2 86 60 0c addcc %i1, 0xc, %l1
<== NOT EXECUTED
rtems_rtl_unresolv_block* name_block = block;
/*
* Is there enough room to fit the name ? It not add a new block.
*/
if (name_recs > (unresolved->block_recs - block->recs))
40010acc: c6 05 20 08 ld [ %l4 + 8 ], %g3
40010ad0: c2 05 a0 04 ld [ %l6 + 4 ], %g1
return ((length + sizeof(rtems_rtl_unresolv_name) - 1) /
40010ad4: 84 05 60 0f add %l5, 0xf, %g2
if (name_recs > (unresolved->block_recs - block->recs))
40010ad8: 82 20 40 03 sub %g1, %g3, %g1
return ((length + sizeof(rtems_rtl_unresolv_name) - 1) /
40010adc: a1 30 a0 04 srl %g2, 4, %l0
if (name_recs > (unresolved->block_recs - block->recs))
40010ae0: 80 a0 40 10 cmp %g1, %l0
40010ae4: 1a 80 00 56 bcc 40010c3c <rtems_rtl_unresolved_add+0x254>
<== ALWAYS TAKEN
40010ae8: a4 10 00 14 mov %l4, %l2
{
name_block = rtems_rtl_unresolved_block_alloc (unresolved);
40010aec: 7f ff fe e2 call 40010674 <rtems_rtl_unresolved_block_alloc>
<== NOT EXECUTED
40010af0: 90 10 00 16 mov %l6, %o0
<== NOT EXECUTED
if (!name_block)
40010af4: a4 92 20 00 orcc %o0, 0, %l2
<== NOT EXECUTED
40010af8: 22 80 00 43 be,a 40010c04 <rtems_rtl_unresolved_add+0x21c>
<== NOT EXECUTED
40010afc: b0 10 20 00 clr %i0
<== NOT EXECUTED
40010b00: 10 80 00 4f b 40010c3c <rtems_rtl_unresolved_add+0x254>
<== NOT EXECUTED
40010b04: c6 04 a0 08 ld [ %l2 + 8 ], %g3
<== NOT EXECUTED
if (rec->type == rtems_rtl_unresolved_name)
40010b08: 80 a0 60 01 cmp %g1, 1
40010b0c: 22 80 00 16 be,a 40010b64 <rtems_rtl_unresolved_add+0x17c>
<== ALWAYS TAKEN
40010b10: c2 15 e0 06 lduh [ %l7 + 6 ], %g1
rec = rtems_rtl_unresolved_rec_next (rec);
40010b14: 7f ff fe c2 call 4001061c <rtems_rtl_unresolved_rec_next>
40010b18: 90 10 00 17 mov %l7, %o0
return !rec || (index >= block->recs) || (rec->type == rtems_rtl_unresolved_empty);
40010b1c: ae 92 20 00 orcc %o0, 0, %l7
40010b20: 22 bf ff e8 be,a 40010ac0 <rtems_rtl_unresolved_add+0xd8>
<== NEVER TAKEN
40010b24: f2 06 40 00 ld [ %i1 ], %i1
<== NOT EXECUTED
int index = (rec - &block->rec) / sizeof (rec);
40010b28: 82 25 c0 11 sub %l7, %l1, %g1
40010b2c: 83 38 60 02 sra %g1, 2, %g1
40010b30: 82 58 40 12 smul %g1, %l2, %g1
40010b34: 83 30 60 02 srl %g1, 2, %g1
return !rec || (index >= block->recs) || (rec->type == rtems_rtl_unresolved_empty);
40010b38: 80 a0 40 10 cmp %g1, %l0
40010b3c: 3a bf ff e1 bcc,a 40010ac0 <rtems_rtl_unresolved_add+0xd8>
<== NEVER TAKEN
40010b40: f2 06 40 00 ld [ %i1 ], %i1
<== NOT EXECUTED
40010b44: c2 05 c0 00 ld [ %l7 ], %g1
40010b48: 80 a0 60 00 cmp %g1, 0
40010b4c: 22 bf ff dd be,a 40010ac0 <rtems_rtl_unresolved_add+0xd8>
40010b50: f2 06 40 00 ld [ %i1 ], %i1
if (rec->type == rtems_rtl_unresolved_name)
40010b54: 80 a0 60 01 cmp %g1, 1
40010b58: 12 bf ff ef bne 40010b14 <rtems_rtl_unresolved_add+0x12c>
<== ALWAYS TAKEN
40010b5c: 01 00 00 00 nop
if ((rec->rec.name.length == length)
40010b60: c2 15 e0 06 lduh [ %l7 + 6 ], %g1
<== NOT EXECUTED
40010b64: 80 a0 40 15 cmp %g1, %l5
40010b68: 02 80 00 04 be 40010b78 <rtems_rtl_unresolved_add+0x190>
<== NEVER TAKEN
40010b6c: 92 10 00 1a mov %i2, %o1
++index;
40010b70: 10 bf ff e9 b 40010b14 <rtems_rtl_unresolved_add+0x12c>
40010b74: a6 04 e0 01 inc %l3
&& (strcmp (rec->rec.name.name, name)))
40010b78: 40 00 2e 0c call 4001c3a8 <strcmp>
<== NOT EXECUTED
40010b7c: 90 05 e0 08 add %l7, 8, %o0
<== NOT EXECUTED
40010b80: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40010b84: 22 bf ff e4 be,a 40010b14 <rtems_rtl_unresolved_add+0x12c>
<== NOT EXECUTED
40010b88: a6 04 e0 01 inc %l3
<== NOT EXECUTED
++rec->rec.name.refs;
40010b8c: c2 15 e0 04 lduh [ %l7 + 4 ], %g1
<== NOT EXECUTED
40010b90: 82 00 60 01 inc %g1
<== NOT EXECUTED
40010b94: c2 35 e0 04 sth %g1, [ %l7 + 4 ]
<== NOT EXECUTED
40010b98: ba 05 20 0c add %l4, 0xc, %i5
<== NOT EXECUTED
40010b9c: c4 05 20 08 ld [ %l4 + 8 ], %g2
<== NOT EXECUTED
return &block->rec + block->recs;
40010ba0: 83 28 a0 03 sll %g2, 3, %g1
<== NOT EXECUTED
40010ba4: 82 20 40 02 sub %g1, %g2, %g1
return false;
}
}
rec = rtems_rtl_unresolved_rec_first_free (block);
rec->type = rtems_rtl_unresolved_reloc;
40010ba8: 84 10 20 02 mov 2, %g2
return &block->rec + block->recs;
40010bac: 83 28 60 02 sll %g1, 2, %g1
rec->type = rtems_rtl_unresolved_reloc;
40010bb0: c4 27 40 01 st %g2, [ %i5 + %g1 ]
return &block->rec + block->recs;
40010bb4: 82 07 40 01 add %i5, %g1, %g1
rec->rec.reloc.obj = obj;
40010bb8: f0 20 60 04 st %i0, [ %g1 + 4 ]
rec->rec.reloc.rel[1] = rel[1];
rec->rec.reloc.rel[2] = rel[2];
++block->recs;
return true;
40010bbc: b0 10 20 01 mov 1, %i0
rec->rec.reloc.flags = flags;
40010bc0: c4 07 a0 48 ld [ %fp + 0x48 ], %g2
40010bc4: c4 30 60 08 sth %g2, [ %g1 + 8 ]
40010bc8: b0 0e 20 ff and %i0, 0xff, %i0
rec->rec.reloc.name = name_index;
40010bcc: e6 30 60 0a sth %l3, [ %g1 + 0xa ]
rec->rec.reloc.sect = sect;
40010bd0: f6 30 60 0c sth %i3, [ %g1 + 0xc ]
rec->rec.reloc.rel[0] = rel[0];
40010bd4: c4 07 00 00 ld [ %i4 ], %g2
40010bd8: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
rec->rec.reloc.rel[1] = rel[1];
40010bdc: c4 07 20 04 ld [ %i4 + 4 ], %g2
40010be0: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
rec->rec.reloc.rel[2] = rel[2];
40010be4: c4 07 20 08 ld [ %i4 + 8 ], %g2
40010be8: c4 20 60 18 st %g2, [ %g1 + 0x18 ]
++block->recs;
40010bec: c2 05 20 08 ld [ %l4 + 8 ], %g1
40010bf0: 82 00 60 01 inc %g1
40010bf4: c2 25 20 08 st %g1, [ %l4 + 8 ]
}
40010bf8: 81 c7 e0 08 ret
40010bfc: 81 e8 00 00 restore
return false;
40010c00: b0 10 20 00 clr %i0
<== NOT EXECUTED
40010c04: b0 0e 20 ff and %i0, 0xff, %i0
<== NOT EXECUTED
}
40010c08: 81 c7 e0 08 ret
<== NOT EXECUTED
40010c0c: 81 e8 00 00 restore
<== NOT EXECUTED
size_t length = strlen (name);
40010c10: 40 00 30 13 call 4001cc5c <strlen>
40010c14: 90 10 00 1a mov %i2, %o0
40010c18: 10 bf ff 9b b 40010a84 <rtems_rtl_unresolved_add+0x9c>
40010c1c: aa 10 00 08 mov %o0, %l5
printf ("rtl: unresolv: add: %s(s:%d) -> %s\n",
40010c20: d2 06 20 18 ld [ %i0 + 0x18 ], %o1
<== NOT EXECUTED
40010c24: 96 10 00 1a mov %i2, %o3
<== NOT EXECUTED
40010c28: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
40010c2c: 11 10 00 c6 sethi %hi(0x40031800), %o0
<== NOT EXECUTED
40010c30: 40 00 1f 46 call 40018948 <__wrap_printf>
<== NOT EXECUTED
40010c34: 90 12 23 18 or %o0, 0x318, %o0 ! 40031b18 <rap_sections+0x19c>
<== NOT EXECUTED
40010c38: 30 bf ff 72 b,a 40010a00 <rtems_rtl_unresolved_add+0x18>
<== NOT EXECUTED
rec->type = rtems_rtl_unresolved_name;
40010c3c: 82 10 20 01 mov 1, %g1
return &block->rec + block->recs;
40010c40: a3 28 e0 03 sll %g3, 3, %l1
40010c44: ba 04 a0 0c add %l2, 0xc, %i5
40010c48: a2 24 40 03 sub %l1, %g3, %l1
40010c4c: a3 2c 60 02 sll %l1, 2, %l1
rec->type = rtems_rtl_unresolved_name;
40010c50: c2 27 40 11 st %g1, [ %i5 + %l1 ]
return &block->rec + block->recs;
40010c54: a2 07 40 11 add %i5, %l1, %l1
rec->rec.name.refs = 1;
40010c58: c2 34 60 04 sth %g1, [ %l1 + 4 ]
rec->rec.name.length = strlen (name) + 1;
40010c5c: 40 00 30 00 call 4001cc5c <strlen>
40010c60: 90 10 00 1a mov %i2, %o0
40010c64: 90 02 20 01 inc %o0
40010c68: d0 34 60 06 sth %o0, [ %l1 + 6 ]
memcpy ((void*) &rec->rec.name.name[0], name, rec->rec.name.length + 1);
40010c6c: 95 2a 20 10 sll %o0, 0x10, %o2
40010c70: 92 10 00 1a mov %i2, %o1
40010c74: 95 32 a0 10 srl %o2, 0x10, %o2
40010c78: 90 04 60 08 add %l1, 8, %o0
40010c7c: 40 00 28 3a call 4001ad64 <memcpy>
40010c80: 94 02 a0 01 inc %o2
block->recs += name_recs;
40010c84: c2 05 20 08 ld [ %l4 + 8 ], %g1
40010c88: 84 04 00 01 add %l0, %g1, %g2
if ((block == name_block) && (block->recs >= unresolved->block_recs))
40010c8c: 80 a4 80 14 cmp %l2, %l4
40010c90: 02 80 00 04 be 40010ca0 <rtems_rtl_unresolved_add+0x2b8>
<== ALWAYS TAKEN
40010c94: c4 25 20 08 st %g2, [ %l4 + 8 ]
40010c98: 10 bf ff c2 b 40010ba0 <rtems_rtl_unresolved_add+0x1b8>
<== NOT EXECUTED
40010c9c: ba 05 20 0c add %l4, 0xc, %i5
<== NOT EXECUTED
40010ca0: c2 05 a0 04 ld [ %l6 + 4 ], %g1
40010ca4: 80 a0 80 01 cmp %g2, %g1
40010ca8: 0a bf ff bf bcs 40010ba4 <rtems_rtl_unresolved_add+0x1bc>
<== ALWAYS TAKEN
40010cac: 83 28 a0 03 sll %g2, 3, %g1
block = rtems_rtl_unresolved_block_alloc (unresolved);
40010cb0: 7f ff fe 71 call 40010674 <rtems_rtl_unresolved_block_alloc>
<== NOT EXECUTED
40010cb4: 90 10 00 16 mov %l6, %o0
<== NOT EXECUTED
if (!block)
40010cb8: a8 92 20 00 orcc %o0, 0, %l4
<== NOT EXECUTED
40010cbc: 02 bf ff d1 be 40010c00 <rtems_rtl_unresolved_add+0x218>
<== NOT EXECUTED
40010cc0: ba 05 20 0c add %l4, 0xc, %i5
<== NOT EXECUTED
40010cc4: 10 bf ff b7 b 40010ba0 <rtems_rtl_unresolved_add+0x1b8>
<== NOT EXECUTED
40010cc8: c4 05 20 08 ld [ %l4 + 8 ], %g2
<== NOT EXECUTED
int index = 1;
40010ccc: 10 bf ff 80 b 40010acc <rtems_rtl_unresolved_add+0xe4>
<== NOT EXECUTED
40010cd0: a6 10 20 01 mov 1, %l3
<== NOT EXECUTED
40010858 <rtems_rtl_unresolved_interate>:
bool
rtems_rtl_unresolved_interate (rtems_rtl_unresolved_iterator iterator,
void* data)
{
40010858: 9d e3 bf a0 save %sp, -96, %sp
rtems_rtl_unresolved* unresolved = rtems_rtl_unresolved_unprotected ();
4001085c: 7f ff ee b1 call 4000c320 <rtems_rtl_unresolved_unprotected>
40010860: 01 00 00 00 nop
if (unresolved)
40010864: 80 a2 20 00 cmp %o0, 0
40010868: 02 80 00 30 be 40010928 <rtems_rtl_unresolved_interate+0xd0>
<== NEVER TAKEN
4001086c: 82 10 20 00 clr %g1
return _Chain_Immutable_head( the_chain )->next;
40010870: f8 02 20 08 ld [ %o0 + 8 ], %i4
return &the_chain->Tail.Node;
40010874: b6 02 20 0c add %o0, 0xc, %i3
{
rtems_chain_node* node = rtems_chain_first (&unresolved->blocks);
while (!rtems_chain_is_tail (&unresolved->blocks, node))
40010878: 80 a7 00 1b cmp %i4, %i3
4001087c: 22 80 00 2c be,a 4001092c <rtems_rtl_unresolved_interate+0xd4>
40010880: b0 08 60 ff and %g1, 0xff, %i0
int index = (rec - &block->rec) / sizeof (rec);
40010884: 35 2d b6 db sethi %hi(0xb6db6c00), %i2
40010888: b4 16 a1 b7 or %i2, 0x1b7, %i2 ! b6db6db7 <RAM_END+0x769b6db7>
return !rec || (index >= block->recs) || (rec->type == rtems_rtl_unresolved_empty);
4001088c: a0 87 20 0c addcc %i4, 0xc, %l0
40010890: 22 80 00 22 be,a 40010918 <rtems_rtl_unresolved_interate+0xc0>
<== NEVER TAKEN
40010894: f8 07 00 00 ld [ %i4 ], %i4
<== NOT EXECUTED
40010898: c2 07 20 08 ld [ %i4 + 8 ], %g1
4001089c: 80 a0 60 00 cmp %g1, 0
400108a0: 22 80 00 1e be,a 40010918 <rtems_rtl_unresolved_interate+0xc0>
<== NEVER TAKEN
400108a4: f8 07 00 00 ld [ %i4 ], %i4
<== NOT EXECUTED
400108a8: c2 07 20 0c ld [ %i4 + 0xc ], %g1
400108ac: 80 a0 60 00 cmp %g1, 0
400108b0: 02 80 00 19 be 40010914 <rtems_rtl_unresolved_interate+0xbc>
<== NEVER TAKEN
400108b4: ba 10 00 10 mov %l0, %i5
rtems_rtl_unresolv_block* block = (rtems_rtl_unresolv_block*) node;
rtems_rtl_unresolv_rec* rec = rtems_rtl_unresolved_rec_first (block);
while (!rtems_rtl_unresolved_rec_is_last (block, rec))
{
if (iterator (rec, data))
400108b8: 92 10 00 19 mov %i1, %o1
400108bc: 9f c6 00 00 call %i0
400108c0: 90 10 00 1d mov %i5, %o0
400108c4: 82 10 00 08 mov %o0, %g1
400108c8: 80 a0 60 00 cmp %g1, 0
400108cc: 12 80 00 17 bne 40010928 <rtems_rtl_unresolved_interate+0xd0>
<== NEVER TAKEN
400108d0: 90 10 00 1d mov %i5, %o0
return true;
rec = rtems_rtl_unresolved_rec_next (rec);
400108d4: 7f ff ff 52 call 4001061c <rtems_rtl_unresolved_rec_next>
400108d8: 01 00 00 00 nop
return !rec || (index >= block->recs) || (rec->type == rtems_rtl_unresolved_empty);
400108dc: ba 92 20 00 orcc %o0, 0, %i5
400108e0: 02 80 00 0d be 40010914 <rtems_rtl_unresolved_interate+0xbc>
<== NEVER TAKEN
400108e4: 82 27 40 10 sub %i5, %l0, %g1
400108e8: c4 07 20 08 ld [ %i4 + 8 ], %g2
int index = (rec - &block->rec) / sizeof (rec);
400108ec: 83 38 60 02 sra %g1, 2, %g1
400108f0: 82 58 40 1a smul %g1, %i2, %g1
400108f4: 83 30 60 02 srl %g1, 2, %g1
return !rec || (index >= block->recs) || (rec->type == rtems_rtl_unresolved_empty);
400108f8: 80 a0 40 02 cmp %g1, %g2
400108fc: 3a 80 00 07 bcc,a 40010918 <rtems_rtl_unresolved_interate+0xc0>
<== NEVER TAKEN
40010900: f8 07 00 00 ld [ %i4 ], %i4
<== NOT EXECUTED
40010904: c2 07 40 00 ld [ %i5 ], %g1
40010908: 80 a0 60 00 cmp %g1, 0
4001090c: 12 bf ff ec bne 400108bc <rtems_rtl_unresolved_interate+0x64>
40010910: 92 10 00 19 mov %i1, %o1
40010914: f8 07 00 00 ld [ %i4 ], %i4
while (!rtems_chain_is_tail (&unresolved->blocks, node))
40010918: 80 a7 00 1b cmp %i4, %i3
4001091c: 32 bf ff dd bne,a 40010890 <rtems_rtl_unresolved_interate+0x38>
<== NEVER TAKEN
40010920: a0 87 20 0c addcc %i4, 0xc, %l0
<== NOT EXECUTED
}
node = rtems_chain_next (node);
}
}
return false;
40010924: 82 10 20 00 clr %g1
40010928: b0 08 60 ff and %g1, 0xff, %i0
}
4001092c: 81 c7 e0 08 ret
40010930: 81 e8 00 00 restore
40010cd4 <rtems_rtl_unresolved_resolve>:
void
rtems_rtl_unresolved_resolve (void)
{
40010cd4: 9d e3 bf 90 save %sp, -112, %sp
rtems_rtl_unresolved_reloc_data rd;
if (rtems_rtl_trace (RTEMS_RTL_TRACE_UNRESOLVED))
40010cd8: 7f ff fe 4b call 40010604 <rtems_rtl_trace>
40010cdc: 90 10 24 00 mov 0x400, %o0
40010ce0: 80 a2 20 00 cmp %o0, 0
40010ce4: 02 80 00 06 be 40010cfc <rtems_rtl_unresolved_resolve+0x28>
40010ce8: 92 07 bf f4 add %fp, -12, %o1
printf ("rtl: unresolv: global resolve\n");
40010cec: 11 10 00 c6 sethi %hi(0x40031800), %o0
40010cf0: 40 00 1f 25 call 40018984 <__wrap_puts>
40010cf4: 90 12 23 40 or %o0, 0x340, %o0 ! 40031b40 <rap_sections+0x1c4>
rd.name = 0;
rd.name_rec = NULL;
rd.sym = NULL;
rtems_rtl_unresolved_interate (rtems_rtl_unresolved_resolve_iterator, &rd);
40010cf8: 92 07 bf f4 add %fp, -12, %o1
rd.name = 0;
40010cfc: c0 37 bf f4 clrh [ %fp + -12 ]
rtems_rtl_unresolved_interate (rtems_rtl_unresolved_resolve_iterator, &rd);
40010d00: 11 10 00 42 sethi %hi(0x40010800), %o0
rd.name_rec = NULL;
40010d04: c0 27 bf f8 clr [ %fp + -8 ]
rtems_rtl_unresolved_interate (rtems_rtl_unresolved_resolve_iterator, &rd);
40010d08: 90 12 21 34 or %o0, 0x134, %o0
40010d0c: 7f ff fe d3 call 40010858 <rtems_rtl_unresolved_interate>
40010d10: c0 27 bf fc clr [ %fp + -4 ]
rtems_rtl_unresolved* unresolved = rtems_rtl_unresolved_unprotected ();
40010d14: 7f ff ed 83 call 4000c320 <rtems_rtl_unresolved_unprotected>
40010d18: 01 00 00 00 nop
if (unresolved)
40010d1c: 80 a2 20 00 cmp %o0, 0
40010d20: 02 80 00 28 be 40010dc0 <rtems_rtl_unresolved_resolve+0xec>
<== NEVER TAKEN
40010d24: a0 02 20 08 add %o0, 8, %l0
return _Chain_Immutable_tail( the_chain )->previous;
40010d28: f6 02 20 10 ld [ %o0 + 0x10 ], %i3
int index = (rec - &block->rec) / sizeof (rec);
40010d2c: 33 2d b6 db sethi %hi(0xb6db6c00), %i1
while (!rtems_chain_is_head (&unresolved->blocks, node))
40010d30: 80 a6 c0 10 cmp %i3, %l0
40010d34: 02 80 00 23 be 40010dc0 <rtems_rtl_unresolved_resolve+0xec>
40010d38: b2 16 61 b7 or %i1, 0x1b7, %i1
40010d3c: f0 06 e0 04 ld [ %i3 + 4 ], %i0
40010d40: f8 06 e0 08 ld [ %i3 + 8 ], %i4
return &block->rec;
40010d44: ba 06 e0 0c add %i3, 0xc, %i5
40010d48: b4 10 00 1d mov %i5, %i2
int index = (rec - &block->rec) / sizeof (rec);
40010d4c: 82 27 40 1a sub %i5, %i2, %g1
40010d50: 83 38 60 02 sra %g1, 2, %g1
40010d54: 82 58 40 19 smul %g1, %i1, %g1
40010d58: 83 30 60 02 srl %g1, 2, %g1
return !rec || (index >= block->recs) || (rec->type == rtems_rtl_unresolved_empty);
40010d5c: 80 a0 40 1c cmp %g1, %i4
40010d60: 1a 80 00 12 bcc 40010da8 <rtems_rtl_unresolved_resolve+0xd4>
40010d64: 80 a7 20 00 cmp %i4, 0
40010d68: c2 07 40 00 ld [ %i5 ], %g1
40010d6c: 80 a0 60 00 cmp %g1, 0
40010d70: 22 80 00 11 be,a 40010db4 <rtems_rtl_unresolved_resolve+0xe0>
40010d74: b6 10 00 18 mov %i0, %i3
if (rec->type == rtems_rtl_unresolved_name)
40010d78: 80 a0 60 01 cmp %g1, 1
40010d7c: 02 80 00 1a be 40010de4 <rtems_rtl_unresolved_resolve+0x110>
40010d80: 80 a0 60 02 cmp %g1, 2
else if (rec->type == rtems_rtl_unresolved_reloc)
40010d84: 22 80 00 25 be,a 40010e18 <rtems_rtl_unresolved_resolve+0x144>
<== ALWAYS TAKEN
40010d88: c2 07 60 04 ld [ %i5 + 4 ], %g1
rec = rtems_rtl_unresolved_rec_next (rec);
40010d8c: 7f ff fe 24 call 4001061c <rtems_rtl_unresolved_rec_next>
40010d90: 90 10 00 1d mov %i5, %o0
40010d94: ba 10 00 08 mov %o0, %i5
return !rec || (index >= block->recs) || (rec->type == rtems_rtl_unresolved_empty);
40010d98: 80 a7 60 00 cmp %i5, 0
40010d9c: 12 bf ff ed bne 40010d50 <rtems_rtl_unresolved_resolve+0x7c>
<== ALWAYS TAKEN
40010da0: 82 27 40 1a sub %i5, %i2, %g1
if (block->recs == 0)
40010da4: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
40010da8: 02 80 00 08 be 40010dc8 <rtems_rtl_unresolved_resolve+0xf4>
<== ALWAYS TAKEN
40010dac: 01 00 00 00 nop
{
40010db0: b6 10 00 18 mov %i0, %i3
<== NOT EXECUTED
while (!rtems_chain_is_head (&unresolved->blocks, node))
40010db4: 80 a6 c0 10 cmp %i3, %l0
40010db8: 32 bf ff e2 bne,a 40010d40 <rtems_rtl_unresolved_resolve+0x6c>
<== NEVER TAKEN
40010dbc: f0 06 e0 04 ld [ %i3 + 4 ], %i0
<== NOT EXECUTED
40010dc0: 81 c7 e0 08 ret
40010dc4: 81 e8 00 00 restore
rtems_chain_extract (node);
40010dc8: 40 00 04 e3 call 40012154 <rtems_chain_extract>
40010dcc: 90 10 00 1b mov %i3, %o0
free (block);
40010dd0: 90 10 00 1b mov %i3, %o0
40010dd4: 7f ff d9 c0 call 400074d4 <free>
40010dd8: b6 10 00 18 mov %i0, %i3
while (!rtems_chain_is_head (&unresolved->blocks, node))
40010ddc: 10 bf ff f7 b 40010db8 <rtems_rtl_unresolved_resolve+0xe4>
40010de0: 80 a6 c0 10 cmp %i3, %l0
if (rec->rec.name.refs == 0)
40010de4: c2 17 60 04 lduh [ %i5 + 4 ], %g1
40010de8: 80 a0 60 00 cmp %g1, 0
40010dec: 12 bf ff e8 bne 40010d8c <rtems_rtl_unresolved_resolve+0xb8>
40010df0: 01 00 00 00 nop
size_t length = strlen (name);
40010df4: 40 00 2f 9a call 4001cc5c <strlen>
40010df8: 90 07 60 08 add %i5, 8, %o0
rtems_rtl_unresolved_clean_block (block, rec, name_recs,
40010dfc: 92 10 00 1d mov %i5, %o1
return ((length + sizeof(rtems_rtl_unresolv_name) - 1) /
40010e00: 94 02 20 0f add %o0, 0xf, %o2
rtems_rtl_unresolved_clean_block (block, rec, name_recs,
40010e04: 90 10 00 1b mov %i3, %o0
40010e08: 7f ff fe 57 call 40010764 <rtems_rtl_unresolved_clean_block.isra.6>
40010e0c: 95 32 a0 04 srl %o2, 4, %o2
40010e10: 10 bf ff e2 b 40010d98 <rtems_rtl_unresolved_resolve+0xc4>
40010e14: f8 06 e0 08 ld [ %i3 + 8 ], %i4
if (!rec->rec.reloc.obj)
40010e18: 80 a0 60 00 cmp %g1, 0
40010e1c: 12 bf ff dc bne 40010d8c <rtems_rtl_unresolved_resolve+0xb8>
40010e20: 94 10 20 01 mov 1, %o2
rtems_rtl_unresolved_clean_block (block, rec, 1,
40010e24: 92 10 00 1d mov %i5, %o1
40010e28: 7f ff fe 4f call 40010764 <rtems_rtl_unresolved_clean_block.isra.6>
40010e2c: 90 10 00 1b mov %i3, %o0
40010e30: 10 bf ff da b 40010d98 <rtems_rtl_unresolved_resolve+0xc4>
40010e34: f8 06 e0 08 ld [ %i3 + 8 ], %i4
40010824 <rtems_rtl_unresolved_table_close>:
void
rtems_rtl_unresolved_table_close (rtems_rtl_unresolved* unresolved)
{
40010824: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40010828: d0 06 20 08 ld [ %i0 + 8 ], %o0
<== NOT EXECUTED
return &the_chain->Tail.Node;
4001082c: b0 06 20 0c add %i0, 0xc, %i0
<== NOT EXECUTED
rtems_chain_node* node = rtems_chain_first (&unresolved->blocks);
while (!rtems_chain_is_tail (&unresolved->blocks, node))
40010830: 80 a2 00 18 cmp %o0, %i0
<== NOT EXECUTED
40010834: 02 80 00 07 be 40010850 <rtems_rtl_unresolved_table_close+0x2c>
<== NOT EXECUTED
40010838: 01 00 00 00 nop
<== NOT EXECUTED
{
rtems_chain_node* next = rtems_chain_next (node);
free (node);
4001083c: 7f ff db 26 call 400074d4 <free>
<== NOT EXECUTED
40010840: fa 02 00 00 ld [ %o0 ], %i5
<== NOT EXECUTED
while (!rtems_chain_is_tail (&unresolved->blocks, node))
40010844: 80 a7 40 18 cmp %i5, %i0
<== NOT EXECUTED
40010848: 12 bf ff fd bne 4001083c <rtems_rtl_unresolved_table_close+0x18>
<== NOT EXECUTED
4001084c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
node = next;
}
}
40010850: 81 c7 e0 08 ret
<== NOT EXECUTED
40010854: 81 e8 00 00 restore
<== NOT EXECUTED
4000c320 <rtems_rtl_unresolved_unprotected>:
rtems_rtl_unresolved*
rtems_rtl_unresolved_unprotected (void)
{
4000c320: 9d e3 bf a0 save %sp, -96, %sp
if (!rtl)
4000c324: 03 10 00 d8 sethi %hi(0x40036000), %g1
4000c328: c2 00 61 e4 ld [ %g1 + 0x1e4 ], %g1 ! 400361e4 <rtl>
4000c32c: 80 a0 60 00 cmp %g1, 0
4000c330: 12 80 00 07 bne 4000c34c <rtems_rtl_unresolved_unprotected+0x2c>
<== ALWAYS TAKEN
4000c334: b0 00 60 7c add %g1, 0x7c, %i0
{
rtems_rtl_set_error (ENOENT, "no rtl");
4000c338: 90 10 20 02 mov 2, %o0
<== NOT EXECUTED
4000c33c: 13 10 00 c3 sethi %hi(0x40030c00), %o1
<== NOT EXECUTED
return NULL;
4000c340: b0 10 20 00 clr %i0
<== NOT EXECUTED
rtems_rtl_set_error (ENOENT, "no rtl");
4000c344: 7f ff fe aa call 4000bdec <rtems_rtl_set_error>
<== NOT EXECUTED
4000c348: 92 12 61 c8 or %o1, 0x1c8, %o1
<== NOT EXECUTED
}
return &rtl->unresolved;
}
4000c34c: 81 c7 e0 08 ret
4000c350: 81 e8 00 00 restore