How to use a c function in assembly

Question

I have a function in assembly called "test" a subfunction in another file called "shift" and a c function called "shiftLetter". My shiftLetter function has two parameters a char with the letter to be shifted and an integer which is the number of shifts. I am trying to send a message to my "shift" function and this function calls my c function to change each letter in this message. However, I am having trouble making this work:

test.asm

extern printf, scanf
extern shift
global _start

section .data

format3 db "%s ",0
message1:     db "This is the Message: ",10,0

original: db "Hello World.",10,0

len1:  equ  $ - original

section .text
        global  main


main:

        mov rsi, message1
        call messages


        mov rdi,original           ;message to change
        mov rsi, len1              ;size of message
        mov rbx, 3                 ;number of shifts
        call shift

        mov rsi, original
        call messages

        ret

; end main                                                                                                                                                                                                  



messages
        mov rdi,format3
        mov rdx,rsi
        mov rax,0
        call printf
        ret

shift.asm

global shift
extern shiftLetter

section .text

shift:

        mov rdx, rsi            ;rdx length of string                                                                                                                                                       

        mov rcx,0
loop:   cmp rcx, rdx
        jge done

        mov rax,  byte [rdi+rcx]    ;getting letter to change (I am sure this is wrong)
        mov r8, rbx             ;number of shifts                                                                                                                                                           
        call shiftLetter
        mov byte [rdi+rcx], rax
        inc rcx

        jmp loop

done:
        ret

Answer 1

1. The details will vary from architecture (e.g. x86 vs. x86-64 vs. MIPS), from platform to platform (e.g. Windows vs. Linux vs MacOS) and from compiler to compiler (e.g. GCC vs. MSVS).

2. Your best bet is to write a small C program and use the C compiler's "dump to assembly" command switch. For example:

test.c:

#include <stdio.h>

void test()
{
  char buf[10];
  buf[0] = 'A';
  buf[1] = 0;
  printf("%s\n", buf);
}

GCC "generate assembly" command line:

gcc -S -O0 x.c
ls -l x.*
-rw-r--r-- 1 root root 105 May  4 19:42 x.c
-rw-r--r-- 1 root root 598 May  4 19:43 x.s

x.s (Equivalent assembler code):

        .file   "x.c"
        .text
        .globl  test
        .type   test, @function
test:
.LFB0:
        .cfi_startproc
        pushq   %rbp
        .cfi_def_cfa_offset 16
        .cfi_offset 6, -16
        movq    %rsp, %rbp
        .cfi_def_cfa_register 6
        subq    $32, %rsp
        movq    %fs:40, %rax
        movq    %rax, -8(%rbp)
        xorl    %eax, %eax
        movb    $65, -18(%rbp)
        movb    $0, -17(%rbp)
        leaq    -18(%rbp), %rax
        movq    %rax, %rdi
        call    puts@PLT
        nop
        movq    -8(%rbp), %rax
        xorq    %fs:40, %rax
        je      .L2
        call    __stack_chk_fail@PLT
.L2:
        leave
        .cfi_def_cfa 7, 8
        ret
        .cfi_endproc
.LFE0:
        .size   test, .-test
        .ident  "GCC: (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0"
        .section        .note.GNU-stack,"",@progbits

You can recognize this where we're initializing "buf[]":

    movb    $65, -18(%rbp)
    movb    $0, -17(%rbp)

And this, where we're calling the C runtime library puts():

    leaq    -18(%rbp), %rax
    movq    %rax, %rdi
    call    puts@PLT

You want to "experiment" with different C code, and see how it translates to assembler in your particular environment.