musl/crt/arm/crtn.s

.weak __init_array_start
.weak __init_array_end
.hidden __init_array_start
.hidden __init_array_end

.section .init
	adr lr, 1f
	ldr r4, 2f
	ldr r5, 2f+4
	add r4, r4, lr
	add r5, r5, lr
1:	adr lr, 1b
	cmp r4, r5
	beq 3f
	ldmia r4!, {r3}
	ldm sp, {r0,r1,r2}
	tst r3,#1
	moveq pc,r3
	bx r3
3:	pop {r0,r1,r2,r4,r5,lr}
	tst lr,#1
	moveq pc,lr
	bx lr
2:	.word __init_array_start-1b
	.word __init_array_end-1b

.section .fini
	pop {r4,r5,r6,lr}
	tst lr,#1
	moveq pc,lr
	bx lr
add support for ctors/dtors on arm with modern gcc a while back, gcc switched from using the old _init/_fini fragments method for calling ctors and dtors on arm to the __init_array and __fini_array method. unfortunately, on glibc this depends on ugly hacks involving making libc.so a linker script and pulling parts of libc into the main program binary. so I cheat a little bit, and just write asm to iterate over the init/fini arrays from the _init/_fini asm. the same approach could be used on any arch it's needed on, but for now arm is the only one. 2012-12-07 23:04:49 -05:00			`.weak __init_array_start`
			`.weak __init_array_end`
fix regression that made shared libs crash on arm 2013-02-03 01:26:33 -05:00			`.hidden __init_array_start`
			`.hidden __init_array_end`
add support for ctors/dtors on arm with modern gcc a while back, gcc switched from using the old _init/_fini fragments method for calling ctors and dtors on arm to the __init_array and __fini_array method. unfortunately, on glibc this depends on ugly hacks involving making libc.so a linker script and pulling parts of libc into the main program binary. so I cheat a little bit, and just write asm to iterate over the init/fini arrays from the _init/_fini asm. the same approach could be used on any arch it's needed on, but for now arm is the only one. 2012-12-07 23:04:49 -05:00
add support for init/finit (constructors and destructors) this is mainly in hopes of supporting c++ (not yet possible for other reasons) but will also help applications/libraries which use (and more often, abuse) the gcc __attribute__((__constructor__)) feature in "C" code. x86_64 and arm versions of the new startup asm are untested and may have minor problems. 2012-02-06 14:39:09 -05:00			`.section .init`
add support for ctors/dtors on arm with modern gcc a while back, gcc switched from using the old _init/_fini fragments method for calling ctors and dtors on arm to the __init_array and __fini_array method. unfortunately, on glibc this depends on ugly hacks involving making libc.so a linker script and pulling parts of libc into the main program binary. so I cheat a little bit, and just write asm to iterate over the init/fini arrays from the _init/_fini asm. the same approach could be used on any arch it's needed on, but for now arm is the only one. 2012-12-07 23:04:49 -05:00			`adr lr, 1f`
			`ldr r4, 2f`
			`ldr r5, 2f+4`
			`add r4, r4, lr`
			`add r5, r5, lr`
			`1: adr lr, 1b`
			`cmp r4, r5`
			`beq 3f`
			`ldmia r4!, {r3}`
			`ldm sp, {r0,r1,r2}`
			`tst r3,#1`
			`moveq pc,r3`
			`bx r3`
			`3: pop {r0,r1,r2,r4,r5,lr}`
add support for init/finit (constructors and destructors) this is mainly in hopes of supporting c++ (not yet possible for other reasons) but will also help applications/libraries which use (and more often, abuse) the gcc __attribute__((__constructor__)) feature in "C" code. x86_64 and arm versions of the new startup asm are untested and may have minor problems. 2012-02-06 14:39:09 -05:00			`tst lr,#1`
			`moveq pc,lr`
			`bx lr`
add support for ctors/dtors on arm with modern gcc a while back, gcc switched from using the old _init/_fini fragments method for calling ctors and dtors on arm to the __init_array and __fini_array method. unfortunately, on glibc this depends on ugly hacks involving making libc.so a linker script and pulling parts of libc into the main program binary. so I cheat a little bit, and just write asm to iterate over the init/fini arrays from the _init/_fini asm. the same approach could be used on any arch it's needed on, but for now arm is the only one. 2012-12-07 23:04:49 -05:00			`2: .word __init_array_start-1b`
			`.word __init_array_end-1b`
add support for init/finit (constructors and destructors) this is mainly in hopes of supporting c++ (not yet possible for other reasons) but will also help applications/libraries which use (and more often, abuse) the gcc __attribute__((__constructor__)) feature in "C" code. x86_64 and arm versions of the new startup asm are untested and may have minor problems. 2012-02-06 14:39:09 -05:00
			`.section .fini`
add support for ctors/dtors on arm with modern gcc a while back, gcc switched from using the old _init/_fini fragments method for calling ctors and dtors on arm to the __init_array and __fini_array method. unfortunately, on glibc this depends on ugly hacks involving making libc.so a linker script and pulling parts of libc into the main program binary. so I cheat a little bit, and just write asm to iterate over the init/fini arrays from the _init/_fini asm. the same approach could be used on any arch it's needed on, but for now arm is the only one. 2012-12-07 23:04:49 -05:00			`pop {r4,r5,r6,lr}`
add support for init/finit (constructors and destructors) this is mainly in hopes of supporting c++ (not yet possible for other reasons) but will also help applications/libraries which use (and more often, abuse) the gcc __attribute__((__constructor__)) feature in "C" code. x86_64 and arm versions of the new startup asm are untested and may have minor problems. 2012-02-06 14:39:09 -05:00			`tst lr,#1`
			`moveq pc,lr`
			`bx lr`