A fundamental introduction to x86 assembly programming

Post by rayiner » Sun, May 15, 2016, 7:53 PM UTC

qb45 wrote: post #59

rayiner wrote: post #50

Earlier quoted context omitted.

x86-64 is really oriented around integer values being 64-bits. For example, 32-bit operations will zero-extend the result to write the full 64-bit integer register. The ABI also assumes integral values are promoted to 64-bits and the stack is 64-bit aligned on calls. That said, as long as you keep RSP aligned you can do whatever you want. Consider this code: extern void value(int* a, int* b, int* c); int main() { int…

Almost correct. If you want to call C code conforming to the x86-64 SYSV ABI, RSP needs to be aligned to 16 bytes when you execute the call . If the code you generate never calls alien code, 8 byte alignment is enough. Since 8 bytes are occupied by return address pushed by the call which started your function, you need to decrease RSP by further 8, 24, 40, 56, 72, ... bytes before calling code generated by others. Re…

Post by vardump » Sun, May 15, 2016, 8:22 PM UTC

Annatar wrote: post #31

dkopi wrote: post #29

Earlier quoted context omitted.

That's less of an assembly issue and more of a compiler/calling convention issue. Assembly allows you to pass parameters on the stack or in registers. Calling conventions simply define a protocol for doing this consistently.

Actually Id'd say that it's mostly the crappy processor design issue: for example, UltraSPARC has 32 physical registers in 32-bit mode, and 256 virtual registers (through register windows, specifically designed for compilers). Even Motorola 68000 with eight general purpose address registers and eight general purpose data registers is far more elegant than a 32-bit four register intel CPU. intel CPU is just crap from…

Post by qb45 » Sun, May 15, 2016, 8:59 PM UTC

wolf550e wrote: post #53

wmu wrote: post #15

> The way the x87 FP stack works is a bit weird, and these days it’s better to do floating-point arithmetic using xmm registers x87 allows to do calculations in extended precision, i.e. word width is 80 bits. SSE is limited to double precision (64-bit words). Also FPU has some advanced math instructions, like sin, cos, tan, exp, etc., and these operations will be available in AVX512F.

Have fun debugging arithmetic difference resulting from spilling an intermediate result to memory and rounding to 64bit value vs. not spilling and keeping the intermediate value as 80 bits.

Post by vardump » Sun, May 15, 2016, 9:49 PM UTC

Annatar wrote: post #67

vardump wrote: post #64

Earlier quoted context omitted.

While x86 is arguably pretty ugly, I think you're being unfair. > ... far more elegant than a 32-bit four register intel CPU. I count eight: EAX, EBX, ECX, EDX, ESI, EDI, EBP, ESP. x86 has also advantage of supporting arbitrary immediate values, so you don't need to allocate registers just for constants.

eax is the accumulator register, ebx the base register, ecx the counter register, edx the data register, esi is the source index, edi is the destination index, ebp is the base pointer, and esp is the stack pointer. When I originally wrote four general purpose registers, I had eax, ebx, ecx and edx in mind, but after fully listing them above, I revise my earlier statement: the x86 assembler has two general purpose reg…

Post by shermanyo » Mon, May 16, 2016, 3:07 AM UTC

pkrumins wrote: post #25

If you want to learn x86 assembly, I recommend one of my favorite books Programming From The Ground Up: http://savannah.nongnu.org/projects/pgubook/ (free pdf!) This is a practical book and teaches assembly programming on Linux. Author Jonathan Bartlett wrote this book because he was frustrated to no end with the existing books. At the end of them he could still ask, "How does the computer really work?" and not have…

    .include "record-def.s"
    .include "linux.s"
    #PURPOSE: This function reads a record from the file descriptor
    #
    #INPUT: The file descriptor and a buffer
    #
    #OUTPUT: This function writes the data to the buffer
    # and returns a status code.
    #
    #STACK LOCAL VARIABLES
    .equ ST_READ_BUFFER, 8
    .equ ST_FILEDES, 12
    .section .text
    .globl read_record
    .type read_record, @function
    read_record:
    pushl %ebp
    movl %esp, %ebp
    pushl %ebx
    movl ST_FILEDES(%ebp), %ebx
    movl ST_READ_BUFFER(%ebp), %ecx
    movl $RECORD_SIZE, %edx
    movl $SYS_READ, %eax
    int $LINUX_SYSCALL
    #NOTE - %eax has the return value, which we will give back to our calling program
    popl %ebx
    movl %ebp, %esp
    popl %ebp
    ret
  

    #System Call Numbers
    .equ SYS_EXIT, 1
    .equ SYS_READ, 3
    .equ SYS_WRITE, 4
    .equ SYS_OPEN, 5
    .equ SYS_CLOSE, 6
    .equ SYS_BRK, 45
  

    .equ RECORD_FIRSTNAME, 0
    .equ RECORD_LASTNAME, 40
    .equ RECORD_ADDRESS, 80
    .equ RECORD_AGE, 320
    .equ RECORD_SIZE, 324