Hacker News new | past | comments | ask | show | jobs | submit login
x86 Assembly Guide (2018) (virginia.edu)
187 points by pcr910303 on Apr 6, 2019 | hide | past | favorite | 20 comments




These links are amazing. I would have never found these. I've been looking for good introductory resources for the past few days now. So glad to see this pop up in my news reader.

Thank you!


Xeno Kovah's courses [0] are excellent for learning assembly.

[0] http://opensecuritytraining.info/


sorry, which news reader are you using?


Archived the stanford one in case it becomes dead https://web.archive.org/web/20190406155050/https://web.stanf...


Also the awesome pdfs by Agner Fog that everyone doing x86-64 programming should read: https://agner.org/optimize/


Awesome!

Any chance you, or anyone else has documentation on x86_64 Windows calling conventions? That's where I've been getting stuck.


https://docs.microsoft.com/en-us/cpp/build/x64-calling-conve...

After you read that, you might want to look at the LLVM source

https://github.com/llvm-mirror/llvm/blob/master/lib/Target/X...

  /// 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.


IIRC: while it's not explicitly documented, x86_64 was late enough in the game that both windows and Unix systems have the same calling convention. Saves a lot of hassle :)


They do not use the same convention. AMD did define a calling convention as part of their SysV ABI spec, and pretty much everybody adopted that ABI... except for Windows.

As to why, the best we have is informed speculation:

https://stackoverflow.com/questions/4429398/why-does-windows...


Nope, the Windows ABI uses a different set of registers than the SysV (Unix) ABI. SysV uses rdi, rsi, rdx, rcx, r8, r9 (in that order), and Windows uses rcx, rdx, r8, r9 (in that order).


It's not just the registers, the use of the stack (e.g. lack of a "red zone" on Windows) as well as the data used for exception handling are different too.

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.


Very useful, thank you!


This is (2006):

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.


In a similar vein, on the quest of understanding yet another abstraction layer deeper, I've been trying to get to grips with how linking/loading works by writing some ELFs by hand.

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!


Hello, sorry I don't have your solution but I'm in your situation with not quite understanding linking. I have a lot of issues with linking/calling C++ and C libraries from each other or other low level languages. My background is in web stuff.

Could you please point me to the resources you used to get to your present level? Thanks :)


Unfortunately, I don't really have a satisfying answer for you.

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:

http://www.muppetlabs.com/~breadbox/software/tiny/

Happy hacking!



Nice to see those mathematical instructions in a simple list. I spent a while recently writing a "math compiler", and it started out using integer multiplication, division, etc.

Now I do it properly with floating-point instructions:

http://github.com/skx/math-compiler/


Does anyone have something like this for ARM?




Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: