Any chance you, or anyone else has documentation on x86_64 Windows calling conventions? That's where I've been getting stuck.
After you read that, you might want to look at the LLVM source
/// The C convention as implemented on Windows/x86-64 and
/// AArch64. This convention differs from the more common
/// \c X86_64_SysV convention in a number of ways, most notably in
/// that XMM registers used to pass arguments are shadowed by GPRs,
/// and vice versa.
/// On AArch64, this is identical to the normal C (AAPCS) calling
/// convention for normal functions, but floats are passed in integer
/// registers to variadic functions.
As to why, the best we have is informed speculation:
The MSDN links above are quite detailed on what Windows implements. The post by Eli at https://eli.thegreenplace.net/2011/09/06/stack-frame-layout-... goes over some Windows differences towards the end.
Credits: This guide was originally created by Adam Ferrari many years ago,
and since updated by Alan Batson, Mike Lack, and Anita Jones. It was revised for 216 Spring 2006 by David Evans.
Dynamic linking is giving me some problems though---I can't seem to get ld.so to do relocs for me. This is almost certainly due to some fundamental misunderstanding of mine, but I don't have the debugging tools to easily correct this.
So far I've just been using readelf and LD_DEBUG to perform basic sanity checking, but now my only idea is to walk through ld.so using gdb.
I'd be much obliged for any suggestions. Cheers!
Could you please point me to the resources you used to get to your present level? Thanks :)
I've picked up most of what I know by haphazzardly putting together information in man files, Intel manuals, and probably bits acquired over time.
That said, here's what comes to mind; first the man pages:
- ld.so(8), ldconfig(8): details about interacting with the loader
- syscall(2): gives some ABI details
- elf(5): pretty much the ELF specification
Links to books and documentation I've found helpful:
- Linkers and Loaders, by John R. Levine: https://linker.iecc.com/,
- The glibc wiki: https://sourceware.org/glibc/wiki/DynamicLoader
- The Intel x86 manuals: https://software.intel.com/en-us/articles/intel-sdm
- The OS Dev Wiki, in general, is a good resource on low-level details: https://wiki.osdev.org/Dynamic_Linker, and
- x86 Opcode and Instruction reference: http://www.ref.x86asm.net/
The last reference above isn't directly about linking, but to make sense of things like symbol relocations, you need some familiarity with instruction encoding.
Finally, Brain Raiter has a neat series of blog on his attempt at writing the smallest ELF files possible. This is what inspired me to write my own ELFs in the first place. The focus is on ELF, but there is by necessity a discussion about how linking and loading works in that context:
Now I do it properly with floating-point instructions: