Calling C++ Code from Assembly

• Since we know the calling convention this is not too bad.
• Today's Files
  • myCaller.asm
  • myLib.cpp
  • myCLib.c
  • Makefile
• First some notes
  • We need to follow the linux calling convention.
    • Apparently this has changed, and is not the WINDOWS calling convention
    • Many tutorials on line are wrong, as is Carter
    • Do not pass the first arguments on the stack, use rdi, rsi, ...
  • I can't get cout to work, so we will use printf.
    • man pages
    • Printf takes at least one argument
      • a format string
      • More arguments are for the format string.
    • The format string contains
      • Normal ascii text.
      • Specifiers for formatting additional arguments.
        • %d is for decimal
        • %s is for null terminated array of characters.
        • That will do for now.
      • printf("%s is %d years old\n",name, age)
  • When calling printf,
    • we need to put the number of floating point registers used in al
    • so zero out rax.
  • We will need to declare the functions we call as extern
    • extern printf
    • Some instructions say to use _printf
• We will be compiling with g++
  • so we need a main
  • Not _start

  • global main
    
    section .text
    main: 

  • g++ normally "mangles" function names.
  • To prevent this we need to add extern "C" to our function declarations.

  • extern "C" void Newline() {
       printf("\n");
    } 

  • Compiling to a .o file from cpp
    • g++ -c -o myLib.o myLib.cpp
    • Make knows how to do this.
  • cc does not mangle names, so no problem.
  • Linking is done with g++
    • -g so we can run gdb

    • nasm -f elf64 -g myCaller.asm -o myCaller.o
      g++    -c -o myLib.o myLib.cpp
      cc    -c -o myCLib.o myCLib.c
      g++ -g myCaller.o myLib.o -o myCaller 

• Calling printf
  • First parameter the format string
  • Make sure it is null terminated.
  • Next parameter, (and all after) data for the format string.
  • rdi, rsi, rdx, rcx, r8, r9, then on the stack.
    • I did not mess with on the stack.
  • Make sure to zero out rax.

  • section .data
    
        format0 db `%s\n\n`,0
        format1 db `%s %d\n`,0
        message db "Hello World!",0
        number1 dd 1234
        count dd 0
    ...
         mov rdi, format0
         mov rsi, message
         mov eax, 0
         call printf
    
         mov rdi, format1
         mov rsi, message
         mov rdx, [count]
         mov eax, 0
         call printf 

• To call a c/c++ function
  • Make sure that you declare the function
    • extern "C" type name(params) in the c++ file
    • extern name in the assembly file.
• A void, no parameter function

  • // c++
    extern "C" void Newline() {
       printf("\n");
    }
    
    extern "C" void PrintHello() {
       printf("Hello world from C++!\n");
       return;
    }
    
    ; assembly
    extern PrintHello
    extern Newline
    ...
         call Newline
         call PrintHello

• Pass by value paramters.
  • Load the value in rdi, rsi, ...
  • Call the function

    ; asm
         mov rdi, 100
         call PrintNumber
    // c++
    extern "C" void PrintNumber(int n) {
       printf("The number is %d\n", n);
       return;
    }

• An integer return value
  • will come back in rax.
  • Other return types will have to be a pass by pointer.

  • ; asm
        mov rdi, 100
         mov rsi, 200
         call AddEm
         mov rdi, rax
         call PrintNumber
    // c++
    extern "C" int AddEm(int a, int b){
       return a+b;
    } 

• A pass by reference
  • load the address in rdi

  • ; asm
         mov rdi, callCount
         call PrintAndIncrement
    // c++
    extern "C" void PrintAndIncrement(int & n) {
       printf("The number is %d\n", n);
       ++n;
       return;
    }

• Array functions: pass the address of the array.

  • ; nasm
         mov rdi, array
         mov rsi, 10
         call FillArray
         call Newline
    
         mov rdi, array
         mov rsi, 10
         call PrintArray
         call Newline
    // C++
    extern "C" void FillArray(int data[], int size) {
       for (int i{0}; i < size; ++i) {
          data[i] = 100 + i;
       }
       return;
    }
    
    extern "C" void PrintArray(const int data[], int size)  {
       for (int i{0}; i < size; ++i) {
          printf("Array[%d] = %d\n", i, data[i]);
       }
       return;
    }