Nasm x86_64 Use Stack For Temp Storage

; strn (string const) macro is overloaded to take 1 or 2 args
; the address and optionally the number of chars to output
; (default 1)
%macro  strn  1
  mov     rax, 1
  mov     rdi, 1
  mov     rsi, %1
  mov     rdx, 1
  syscall
%endmacro

%macro  strn  2
  mov     rax, 1
  mov     rdi, 1
  mov     rsi, %1
  mov     rdx, %2
  syscall
%endmacro

section .data

  nwln db 0xa                             ; newline
  abet db "abcdefghijklmnopqrstuvwxyz"    ; alphabet
  ablen equ $ - abet                      ; alphabet len

section .bss

section .text
      global _start

  _start:

      sub     rsp, 32             ; grow stack by 32-bytes

      xor     rcx, rcx            ; zero rcx
      mov     cl, ablen           ; set count register to ablen

      mov     rsi, abet           ; address of source in rsi
      mov     rdi, rsp            ; address of dest in rdi
      rep     movsb               ; copy string to stack at rsp

      strn    abet, ablen         ; output string from abet
      strn    nwln                ; output newline

      strn    rsp, ablen          ; output string from copy
      strn    nwln                ; output newline

      lea     rsi, [abet + 14]    ; address of 15th, 'o' from abet
      strn    rsi                 ; output char
      strn    nwln                ; output newline

      lea     rsi, [rsp + 14]     ; address of 15th, 'o' from copy
      strn    rsi                 ; output char
      strn    nwln                ; output newline

      lea     rsi, [rsp + ablen - 1]  ; load addr of 'z' in rsi

  prnchar:                        ; print from copy in reverse
      strn    rsi                 ; print char at rsi
      dec     rsi                 ; decrement address
      cmp     rsi, rsp            ; compare to rsp
      jge prnchar                 ; loop through rsi == rsp
      strn    nwln                ; output newline

      mov     rsi, rsp            ; load copy to rsi

  eachchar:                       ; print every other char
      strn    rsi                 ; print char at rsi
      inc     rsi                 ; increment address at rsi
      mov     al, 0               ; load 0 in al
      cmp     al, byte[rsi]       ; compare byte
      je      exit                ; if end, jump to exit
      inc     rsi                 ; skip to next char
      cmp     al, byte[rsi]       ; compare byte
      jne     eachchar            ; repeat until nul-char reached

  exit:
      strn    nwln                ; output newline

      add     rsp, 32             ; restore stack pointer address

      xor     rdi, rdi            ; set zero exit code
      mov     rax, 60             ; set syscall number to 60 (0x3c hex)
      syscall                     ; call kernel