Skip to content

Instantly share code, notes, and snippets.

@yuyichao

yuyichao/jl_compute_field_offsets.s

Created January 6, 2016 00:58
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save yuyichao/aafc2bc3a6e96f624378 to your computer and use it in GitHub Desktop.
Save yuyichao/aafc2bc3a6e96f624378 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
jl_compute_field_offsets.s
000a14a4 <jl_compute_field_offsets>:
void jl_breakpoint(jl_value_t *v);
void jl_compute_field_offsets(jl_datatype_t *st)
{
a14a4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
a14a8: e1a04000 mov r4, r0
a14ac: e28db020 add fp, sp, #32
if (st->name->name == jl_symbol("ImmutableDict")) {
a14b0: e59f0364 ldr r0, [pc, #868] ; a181c <jl_compute_field_offsets+0x378>
return t;
}
void jl_breakpoint(jl_value_t *v);
void jl_compute_field_offsets(jl_datatype_t *st)
{
a14b4: e24dd034 sub sp, sp, #52 ; 0x34
if (st->name->name == jl_symbol("ImmutableDict")) {
a14b8: e5943000 ldr r3, [r4]
a14bc: e08f0000 add r0, pc, r0
return t;
}
void jl_breakpoint(jl_value_t *v);
void jl_compute_field_offsets(jl_datatype_t *st)
{
a14c0: e59f2358 ldr r2, [pc, #856] ; a1820 <jl_compute_field_offsets+0x37c>
if (st->name->name == jl_symbol("ImmutableDict")) {
a14c4: e5935000 ldr r5, [r3]
return t;
}
void jl_breakpoint(jl_value_t *v);
void jl_compute_field_offsets(jl_datatype_t *st)
{
a14c8: e08f2002 add r2, pc, r2
a14cc: e50b2044 str r2, [fp, #-68] ; 0xffffffbc
if (st->name->name == jl_symbol("ImmutableDict")) {
a14d0: ebfffed1 bl a101c <jl_symbol>
a14d4: e1550000 cmp r5, r0
a14d8: 0a0000cc beq a1810 <jl_compute_field_offsets+0x36c>
int ptrfree = 1;
assert(0 <= st->fielddesc_type && st->fielddesc_type <= 2);
uint64_t max_offset = (((uint64_t)1) <<
(1 << (3 + st->fielddesc_type))) - 1;
a14dc: e5d43027 ldrb r3, [r4, #39] ; 0x27
size_t sz = 0, alignm = 1;
int ptrfree = 1;
assert(0 <= st->fielddesc_type && st->fielddesc_type <= 2);
uint64_t max_offset = (((uint64_t)1) <<
a14e0: e3a02001 mov r2, #1
(1 << (3 + st->fielddesc_type))) - 1;
uint64_t max_size = max_offset >> 1;
for(size_t i=0; i < jl_datatype_nfields(st); i++) {
a14e4: e594c020 ldr ip, [r4, #32]
size_t sz = 0, alignm = 1;
int ptrfree = 1;
assert(0 <= st->fielddesc_type && st->fielddesc_type <= 2);
uint64_t max_offset = (((uint64_t)1) <<
a14e8: e1a03323 lsr r3, r3, #6
a14ec: e2833003 add r3, r3, #3
a14f0: e1a03312 lsl r3, r2, r3
a14f4: e2435020 sub r5, r3, #32
a14f8: e263e020 rsb lr, r3, #32
a14fc: e1a01512 lsl r1, r2, r5
a1500: e1a00312 lsl r0, r2, r3
a1504: e2506001 subs r6, r0, #1
a1508: e1811e32 orr r1, r1, r2, lsr lr
a150c: e2c17000 sbc r7, r1, #0
a1510: e14b63fc strd r6, [fp, #-60] ; 0xffffffc4
(1 << (3 + st->fielddesc_type))) - 1;
uint64_t max_size = max_offset >> 1;
a1514: e1b070a7 lsrs r7, r7, #1
a1518: e1a06066 rrx r6, r6
for(size_t i=0; i < jl_datatype_nfields(st); i++) {
a151c: e35c0000 cmp ip, #0
assert(0 <= st->fielddesc_type && st->fielddesc_type <= 2);
uint64_t max_offset = (((uint64_t)1) <<
(1 << (3 + st->fielddesc_type))) - 1;
uint64_t max_size = max_offset >> 1;
a1520: e14b64fc strd r6, [fp, #-76] ; 0xffffffb4
for(size_t i=0; i < jl_datatype_nfields(st); i++) {
a1524: 0a0000af beq a17e8 <jl_compute_field_offsets+0x344>
a1528: e51b1044 ldr r1, [fp, #-68] ; 0xffffffbc
a152c: e2849034 add r9, r4, #52 ; 0x34
a1530: e59f32ec ldr r3, [pc, #748] ; a1824 <jl_compute_field_offsets+0x380>
a1534: e3a06000 mov r6, #0
a1538: e50b2034 str r2, [fp, #-52] ; 0xffffffcc
a153c: e1a07009 mov r7, r9
a1540: e1a05009 mov r5, r9
a1544: e1a0a006 mov sl, r6
a1548: e7918003 ldr r8, [r1, r3]
a154c: e50b9028 str r9, [fp, #-40] ; 0xffffffd8
a1550: e50b2030 str r2, [fp, #-48] ; 0xffffffd0
a1554: e1a01008 mov r1, r8
a1558: ea000032 b a1628 <jl_compute_field_offsets+0x184>
} \
}
DEFINE_FIELD_ACCESSORS(offset)
DEFINE_FIELD_ACCESSORS(size)
DEFINE_FIELD_ACCESSORS(isptr)
a155c: e5d53001 ldrb r3, [r5, #1]
a1560: e3833080 orr r3, r3, #128 ; 0x80
a1564: e5c53001 strb r3, [r5, #1]
a1568: e3a02004 mov r2, #4
a156c: e3a08004 mov r8, #4
a1570: e3a09000 mov r9, #0
a1574: e1a00002 mov r0, r2
a1578: e3a0c003 mov ip, #3
a157c: e3e03003 mvn r3, #3
a1580: e3a0e000 mov lr, #0
a1584: e50be034 str lr, [fp, #-52] ; 0xffffffcc
jl_field_setisptr(st, i, 1);
ptrfree = 0;
}
if (al != 0) {
size_t alsz = LLT_ALIGN(sz, al);
if (sz & (al - 1))
a1588: e11a000c tst sl, ip
al = fsz;
jl_field_setisptr(st, i, 1);
ptrfree = 0;
}
if (al != 0) {
size_t alsz = LLT_ALIGN(sz, al);
a158c: e24aa001 sub sl, sl, #1
a1590: e08aa002 add sl, sl, r2
a1594: e00aa003 and sl, sl, r3
if (sz & (al - 1))
st->haspadding = 1;
a1598: 15d43027 ldrbne r3, [r4, #39] ; 0x27
a159c: 13833020 orrne r3, r3, #32
a15a0: 15c43027 strbne r3, [r4, #39] ; 0x27
a15a4: e51b3030 ldr r3, [fp, #-48] ; 0xffffffd0
a15a8: e1530002 cmp r3, r2
a15ac: 31a03002 movcc r3, r2
a15b0: e50b3030 str r3, [fp, #-48] ; 0xffffffd0
else { \
((jl_fielddesc32_t*)jl_datatype_fields(st))[i].f = val; \
} \
}
DEFINE_FIELD_ACCESSORS(offset)
a15b4: e5d43027 ldrb r3, [r4, #39] ; 0x27
a15b8: e21330c0 ands r3, r3, #192 ; 0xc0
a15bc: 05c5a000 strbeq sl, [r5]
a15c0: 0a000003 beq a15d4 <jl_compute_field_offsets+0x130>
a15c4: e3530040 cmp r3, #64 ; 0x40
a15c8: 1587a000 strne sl, [r7]
a15cc: 051b3028 ldreq r3, [fp, #-40] ; 0xffffffd8
a15d0: 01c3a0b0 strheq sl, [r3]
DEFINE_FIELD_ACCESSORS(size)
a15d4: e5d43027 ldrb r3, [r4, #39] ; 0x27
a15d8: e21330c0 ands r3, r3, #192 ; 0xc0
a15dc: 1a000026 bne a167c <jl_compute_field_offsets+0x1d8>
a15e0: e5d53001 ldrb r3, [r5, #1]
a15e4: e7c63010 bfi r3, r0, #0, #7
a15e8: e5c53001 strb r3, [r5, #1]
if (al > alignm)
alignm = al;
}
jl_field_setoffset(st, i, sz);
jl_field_setsize(st, i, fsz);
if (__unlikely(max_offset - sz < fsz))
a15ec: e14b23dc ldrd r2, [fp, #-60] ; 0xffffffc4
a15f0: e052200a subs r2, r2, sl
a15f4: e2c33000 sbc r3, r3, #0
a15f8: e1530009 cmp r3, r9
a15fc: 01520008 cmpeq r2, r8
a1600: 3a000051 bcc a174c <jl_compute_field_offsets+0x2a8>
uint64_t max_offset = (((uint64_t)1) <<
(1 << (3 + st->fielddesc_type))) - 1;
uint64_t max_size = max_offset >> 1;
for(size_t i=0; i < jl_datatype_nfields(st); i++) {
a1604: e5943020 ldr r3, [r4, #32]
}
jl_field_setoffset(st, i, sz);
jl_field_setsize(st, i, fsz);
if (__unlikely(max_offset - sz < fsz))
jl_throw(jl_overflow_exception);
sz += fsz;
a1608: e08aa000 add sl, sl, r0
a160c: e51b2028 ldr r2, [fp, #-40] ; 0xffffffd8
a1610: e2855002 add r5, r5, #2
uint64_t max_offset = (((uint64_t)1) <<
(1 << (3 + st->fielddesc_type))) - 1;
uint64_t max_size = max_offset >> 1;
for(size_t i=0; i < jl_datatype_nfields(st); i++) {
a1614: e1530006 cmp r3, r6
a1618: e2877008 add r7, r7, #8
a161c: e2822004 add r2, r2, #4
a1620: e50b2028 str r2, [fp, #-40] ; 0xffffffd8
a1624: 9a000055 bls a1780 <jl_compute_field_offsets+0x2dc>
STATIC_INLINE jl_value_t *jl_svecref(void *t, size_t i)
{
assert(jl_typeis(t,jl_simplevector_type));
assert(i < jl_svec_len(t));
return jl_svec_data(t)[i];
a1628: e594300c ldr r3, [r4, #12]
a162c: e2866001 add r6, r6, #1
}
STATIC_INLINE int jl_isbits(void *t) // corresponding to isbits() in julia
{
return (jl_is_datatype(t) && !((jl_datatype_t*)t)->mutabl &&
((jl_datatype_t*)t)->pointerfree && !((jl_datatype_t*)t)->abstract);
a1630: e5910000 ldr r0, [r1]
STATIC_INLINE jl_value_t *jl_svecref(void *t, size_t i)
{
assert(jl_typeis(t,jl_simplevector_type));
assert(i < jl_svec_len(t));
return jl_svec_data(t)[i];
a1634: e7933106 ldr r3, [r3, r6, lsl #2]
}
STATIC_INLINE int jl_isbits(void *t) // corresponding to isbits() in julia
{
return (jl_is_datatype(t) && !((jl_datatype_t*)t)->mutabl &&
((jl_datatype_t*)t)->pointerfree && !((jl_datatype_t*)t)->abstract);
a1638: e5132004 ldr r2, [r3, #-4]
STATIC_INLINE jl_value_t *jl_svecref(void *t, size_t i)
{
assert(jl_typeis(t,jl_simplevector_type));
assert(i < jl_svec_len(t));
return jl_svec_data(t)[i];
a163c: e50b302c str r3, [fp, #-44] ; 0xffffffd4
}
STATIC_INLINE int jl_isbits(void *t) // corresponding to isbits() in julia
{
return (jl_is_datatype(t) && !((jl_datatype_t*)t)->mutabl &&
((jl_datatype_t*)t)->pointerfree && !((jl_datatype_t*)t)->abstract);
a1640: e3c2200f bic r2, r2, #15
a1644: e1500002 cmp r0, r2
a1648: 0a000014 beq a16a0 <jl_compute_field_offsets+0x1fc>
} \
}
DEFINE_FIELD_ACCESSORS(offset)
DEFINE_FIELD_ACCESSORS(size)
DEFINE_FIELD_ACCESSORS(isptr)
a164c: e5d43027 ldrb r3, [r4, #39] ; 0x27
a1650: e21330c0 ands r3, r3, #192 ; 0xc0
a1654: 0affffc0 beq a155c <jl_compute_field_offsets+0xb8>
a1658: e3530040 cmp r3, #64 ; 0x40
a165c: 051b2028 ldreq r2, [fp, #-40] ; 0xffffffd8
a1660: 15d73007 ldrbne r3, [r7, #7]
a1664: 05d23003 ldrbeq r3, [r2, #3]
a1668: 13833080 orrne r3, r3, #128 ; 0x80
a166c: 15c73007 strbne r3, [r7, #7]
a1670: 03833080 orreq r3, r3, #128 ; 0x80
a1674: 05c23003 strbeq r3, [r2, #3]
a1678: eaffffba b a1568 <jl_compute_field_offsets+0xc4>
((jl_fielddesc32_t*)jl_datatype_fields(st))[i].f = val; \
} \
}
DEFINE_FIELD_ACCESSORS(offset)
DEFINE_FIELD_ACCESSORS(size)
a167c: e3530040 cmp r3, #64 ; 0x40
a1680: 051b2028 ldreq r2, [fp, #-40] ; 0xffffffd8
a1684: 15973004 ldrne r3, [r7, #4]
a1688: 01d230b2 ldrheq r3, [r2, #2]
a168c: 17de3010 bfine r3, r0, #0, #31
a1690: 15873004 strne r3, [r7, #4]
a1694: 07ce3010 bfieq r3, r0, #0, #15
a1698: 01c230b2 strheq r3, [r2, #2]
a169c: eaffffd2 b a15ec <jl_compute_field_offsets+0x148>
!((jl_datatype_t*)(v))->abstract);
}
STATIC_INLINE int jl_isbits(void *t) // corresponding to isbits() in julia
{
return (jl_is_datatype(t) && !((jl_datatype_t*)t)->mutabl &&
a16a0: e5d32019 ldrb r2, [r3, #25]
a16a4: e3520000 cmp r2, #0
a16a8: 1affffe7 bne a164c <jl_compute_field_offsets+0x1a8>
a16ac: e5d3201a ldrb r2, [r3, #26]
a16b0: e3520000 cmp r2, #0
a16b4: 0affffe4 beq a164c <jl_compute_field_offsets+0x1a8>
((jl_datatype_t*)t)->pointerfree && !((jl_datatype_t*)t)->abstract);
a16b8: e5d33018 ldrb r3, [r3, #24]
a16bc: e3530000 cmp r3, #0
a16c0: e50b3050 str r3, [fp, #-80] ; 0xffffffb0
a16c4: 1affffe0 bne a164c <jl_compute_field_offsets+0x1a8>
jl_value_t *ty = jl_field_type(st, i);
size_t fsz, al;
if (jl_isbits(ty) && jl_is_leaf_type(ty)) {
a16c8: e51b002c ldr r0, [fp, #-44] ; 0xffffffd4
a16cc: e50b1040 str r1, [fp, #-64] ; 0xffffffc0
a16d0: ebff5464 bl 76868 <jl_is_leaf_type>
a16d4: e51b1040 ldr r1, [fp, #-64] ; 0xffffffc0
a16d8: e3500000 cmp r0, #0
a16dc: 0affffda beq a164c <jl_compute_field_offsets+0x1a8>
fsz = jl_datatype_size(ty);
a16e0: e51b302c ldr r3, [fp, #-44] ; 0xffffffd4
// Should never happen
if (__unlikely(fsz > max_size))
a16e4: e3a09000 mov r9, #0
for(size_t i=0; i < jl_datatype_nfields(st); i++) {
jl_value_t *ty = jl_field_type(st, i);
size_t fsz, al;
if (jl_isbits(ty) && jl_is_leaf_type(ty)) {
fsz = jl_datatype_size(ty);
a16e8: e5930014 ldr r0, [r3, #20]
// Should never happen
if (__unlikely(fsz > max_size))
a16ec: e14b24dc ldrd r2, [fp, #-76] ; 0xffffffb4
a16f0: e1530009 cmp r3, r9
a16f4: e1a08000 mov r8, r0
a16f8: 01520000 cmpeq r2, r0
a16fc: 3a000012 bcc a174c <jl_compute_field_offsets+0x2a8>
jl_throw(jl_overflow_exception);
al = ((jl_datatype_t*)ty)->alignment;
a1700: e51b302c ldr r3, [fp, #-44] ; 0xffffffd4
} \
}
DEFINE_FIELD_ACCESSORS(offset)
DEFINE_FIELD_ACCESSORS(size)
DEFINE_FIELD_ACCESSORS(isptr)
a1704: e5d4c027 ldrb ip, [r4, #39] ; 0x27
a1708: e5932024 ldr r2, [r3, #36] ; 0x24
a170c: e21cc0c0 ands ip, ip, #192 ; 0xc0
a1710: e7fc2052 ubfx r2, r2, #0, #29
a1714: 1a000011 bne a1760 <jl_compute_field_offsets+0x2bc>
a1718: e5d5e001 ldrb lr, [r5, #1]
a171c: e7c7e39c bfi lr, ip, #7, #1
a1720: e5c5e001 strb lr, [r5, #1]
jl_field_setisptr(st, i, 0);
if (((jl_datatype_t*)ty)->haspadding)
a1724: e5d33027 ldrb r3, [r3, #39] ; 0x27
a1728: e3130020 tst r3, #32
st->haspadding = 1;
a172c: 15d43027 ldrbne r3, [r4, #39] ; 0x27
a1730: 13833020 orrne r3, r3, #32
a1734: 15c43027 strbne r3, [r4, #39] ; 0x27
fsz = MAX_ALIGN;
al = fsz;
jl_field_setisptr(st, i, 1);
ptrfree = 0;
}
if (al != 0) {
a1738: e3520000 cmp r2, #0
a173c: 0affff9c beq a15b4 <jl_compute_field_offsets+0x110>
a1740: e2623000 rsb r3, r2, #0
a1744: e242c001 sub ip, r2, #1
a1748: eaffff8e b a1588 <jl_compute_field_offsets+0xe4>
alignm = al;
}
jl_field_setoffset(st, i, sz);
jl_field_setsize(st, i, fsz);
if (__unlikely(max_offset - sz < fsz))
jl_throw(jl_overflow_exception);
a174c: e59f30d4 ldr r3, [pc, #212] ; a1828 <jl_compute_field_offsets+0x384>
a1750: e51b2044 ldr r2, [fp, #-68] ; 0xffffffbc
a1754: e7923003 ldr r3, [r2, r3]
a1758: e5930000 ldr r0, [r3]
a175c: eb001516 bl a6bbc <jl_throw>
a1760: e35c0040 cmp ip, #64 ; 0x40
a1764: 0a000018 beq a17cc <jl_compute_field_offsets+0x328>
a1768: e51b3050 ldr r3, [fp, #-80] ; 0xffffffb0
a176c: e5d7c007 ldrb ip, [r7, #7]
a1770: e7c7c393 bfi ip, r3, #7, #1
a1774: e5c7c007 strb ip, [r7, #7]
a1778: e51b302c ldr r3, [fp, #-44] ; 0xffffffd4
a177c: eaffffe8 b a1724 <jl_compute_field_offsets+0x280>
a1780: e51b0030 ldr r0, [fp, #-48] ; 0xffffffd0
sz += fsz;
}
st->alignment = alignm;
a1784: e5941024 ldr r1, [r4, #36] ; 0x24
st->size = LLT_ALIGN(sz, alignm);
a1788: e080300a add r3, r0, sl
a178c: e2602000 rsb r2, r0, #0
a1790: e2433001 sub r3, r3, #1
jl_field_setsize(st, i, fsz);
if (__unlikely(max_offset - sz < fsz))
jl_throw(jl_overflow_exception);
sz += fsz;
}
st->alignment = alignm;
a1794: e7dc1010 bfi r1, r0, #0, #29
st->size = LLT_ALIGN(sz, alignm);
a1798: e0033002 and r3, r3, r2
jl_field_setsize(st, i, fsz);
if (__unlikely(max_offset - sz < fsz))
jl_throw(jl_overflow_exception);
sz += fsz;
}
st->alignment = alignm;
a179c: e5841024 str r1, [r4, #36] ; 0x24
st->size = LLT_ALIGN(sz, alignm);
if (st->size > sz)
a17a0: e15a0003 cmp sl, r3
if (__unlikely(max_offset - sz < fsz))
jl_throw(jl_overflow_exception);
sz += fsz;
}
st->alignment = alignm;
st->size = LLT_ALIGN(sz, alignm);
a17a4: e5843014 str r3, [r4, #20]
if (st->size > sz)
st->haspadding = 1;
a17a8: 35d43027 ldrbcc r3, [r4, #39] ; 0x27
a17ac: 33833020 orrcc r3, r3, #32
a17b0: 35c43027 strbcc r3, [r4, #39] ; 0x27
st->pointerfree = ptrfree && !st->abstract;
a17b4: e51b3034 ldr r3, [fp, #-52] ; 0xffffffcc
a17b8: e3530000 cmp r3, #0
a17bc: 1a00000d bne a17f8 <jl_compute_field_offsets+0x354>
a17c0: e5c4301a strb r3, [r4, #26]
}
a17c4: e24bd020 sub sp, fp, #32
a17c8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
a17cc: e51be028 ldr lr, [fp, #-40] ; 0xffffffd8
a17d0: e51b3050 ldr r3, [fp, #-80] ; 0xffffffb0
a17d4: e5dec003 ldrb ip, [lr, #3]
a17d8: e7c7c393 bfi ip, r3, #7, #1
a17dc: e5cec003 strb ip, [lr, #3]
a17e0: e51b302c ldr r3, [fp, #-44] ; 0xffffffd4
a17e4: eaffffce b a1724 <jl_compute_field_offsets+0x280>
jl_field_setsize(st, i, fsz);
if (__unlikely(max_offset - sz < fsz))
jl_throw(jl_overflow_exception);
sz += fsz;
}
st->alignment = alignm;
a17e8: e5943024 ldr r3, [r4, #36] ; 0x24
st->size = LLT_ALIGN(sz, alignm);
a17ec: e584c014 str ip, [r4, #20]
jl_field_setsize(st, i, fsz);
if (__unlikely(max_offset - sz < fsz))
jl_throw(jl_overflow_exception);
sz += fsz;
}
st->alignment = alignm;
a17f0: e7dc3012 bfi r3, r2, #0, #29
a17f4: e5843024 str r3, [r4, #36] ; 0x24
a17f8: e5d43018 ldrb r3, [r4, #24]
a17fc: e16f3f13 clz r3, r3
a1800: e1a032a3 lsr r3, r3, #5
st->size = LLT_ALIGN(sz, alignm);
if (st->size > sz)
st->haspadding = 1;
st->pointerfree = ptrfree && !st->abstract;
a1804: e5c4301a strb r3, [r4, #26]
}
a1808: e24bd020 sub sp, fp, #32
a180c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
void jl_breakpoint(jl_value_t *v);
void jl_compute_field_offsets(jl_datatype_t *st)
{
if (st->name->name == jl_symbol("ImmutableDict")) {
jl_breakpoint((jl_value_t*)st);
a1810: e1a00004 mov r0, r4
a1814: ebffe99d bl 9be90 <jl_breakpoint>
a1818: eaffff2f b a14dc <jl_compute_field_offsets+0x38>
a181c: 00c06284 .word 0x00c06284
a1820: 00d754e0 .word 0x00d754e0
a1824: 00001120 .word 0x00001120
a1828: 00001258 .word 0x00001258
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment