Reworth the 7th chapter

.gitignore

@@ -57,3 +57,6 @@ sum/sum
 stack/stack
 strings/reverse
 float/dot_product
+casm/casm1/casm
+casm/casm2/casm
+casm/casm3/casm

README.md

@@ -21,13 +21,13 @@ Have fun!
 
 Here are links to each post:
 
-  * [Part 1. Introduction](https://github.com/0xAX/asm/blob/master/content/asm_1.md)
-  * [Part 2. The `x86_64` concepts](https://github.com/0xAX/asm/blob/master/content/asm_2.md)
-  * [Part 3. Journey through the stack](https://github.com/0xAX/asm/blob/master/content/asm_3.md)
-  * [Part 4. Data manipulation](https://github.com/0xAX/asm/blob/master/content/asm_4.md)
-  * [Part 5. Macros](https://github.com/0xAX/asm/blob/master/content/asm_5.md)
-  * [Part 6. Floating-point arithmetic](https://github.com/0xAX/asm/blob/master/content/asm_6.md)
-  * [Say hello to x86_64 Assembly part 7](https://github.com/0xAX/asm/blob/master/content/asm_7.md)
+- [Part 1. Introduction](https://github.com/0xAX/asm/blob/master/content/asm_1.md)
+- [Part 2. The `x86_64` concepts](https://github.com/0xAX/asm/blob/master/content/asm_2.md)
+- [Part 3. Journey through the stack](https://github.com/0xAX/asm/blob/master/content/asm_3.md)
+- [Part 4. Data manipulation](https://github.com/0xAX/asm/blob/master/content/asm_4.md)
+- [Part 5. Macros](https://github.com/0xAX/asm/blob/master/content/asm_5.md)
+- [Part 6. Floating-point arithmetic](https://github.com/0xAX/asm/blob/master/content/asm_6.md)
+- [Part 7. Assembly interaction with high-level programming languages](https://github.com/0xAX/asm/blob/master/content/asm_7.md)
 
 ## Requirements
 

casm/README.md

@@ -0,0 +1,15 @@
+# Assembly interaction with high-level programming languages
+
+These are three simple programs that provide examples of the interaction between assembly and the C programming language:
+
+- [casm1](./casm1/) - call the C function from asm
+- [casm2](./casm2/) - GCC inline assembly
+- [casm3](./casm3/) - call the asm function from C
+
+To build each program, go to its directory and run:
+
+```bash
+make
+```
+
+For more details, read [Part 7. Assembly interaction with high-level programming languages](https://github.com/0xAX/asm/blob/master/content/asm_7.md).

casm/casm1/Makefile

@@ -1,7 +1,6 @@
-buildAsmc:
-	gcc  -c casm.c -o c.o
+all:
 	nasm -f elf64 casm.asm -o casm.o
-	ld   -dynamic-linker /lib64/ld-linux-x86-64.so.2 -lc casm.o c.o -o casm
+	ld -dynamic-linker /lib64/ld-linux-x86-64.so.2 -lc casm.o -o casm
 
 clean:
 	rm -rf *.o

casm/casm1/casm.asm

@@ -1,12 +1,28 @@
-global _start
+;; Definition of the `data` section
+section .data
+    ;; String variable with the value `hello world!`
+    msg db "hello, world!"
 
-extern print
+    ;; Reference to the C stdlib functions that we will use
+    extern write, exit
 
+;; Definition of the text section
 section .text
+    ;; Reference to the entry point of our program
+    global _start
 
+;; Entry point
 _start:
-	call	print
+    ;; Set the first argument of the `write` function to 1 (`stdout`).
+    mov rdi, 1
+    ;; Set the second argument of the `write` function to the reference of the `msg` variable.
+    mov rsi, msg
+    ;; Set the third argument to the length of the `msg` variable's value (13 bytes).
+    mov rdx, 13
+    ;; Call the `write` function.
+    call write
 
-	mov	rax, 60
-	mov	rdi, 0
-	syscall
+    ;; Set the first argument of `sys_exit` to 0. The 0 status code is success.
+    mov rdi, 0
+    ;; Call the `exit` function
+    call exit

casm/casm2/Makefile

@@ -1,2 +1,6 @@
-build:
-	gcc casm.c -o casm 
+all:
+	gcc casm.c -o casm
+
+clean:
+	rm -rf *.o
+	rm -rf casm

casm/casm2/casm.c

@@ -1,17 +1,19 @@
+#include <stdio.h>
 #include <string.h>
 
 int main() {
-	char* str = "Hello World\n";
-	long len = strlen(str);
-	int ret = 0;
+        char* str = "Hello World\n";
+        long len = strlen(str);
+        int ret = 0;
 
-	__asm__("movq $1, %%rax \n\t"
-		"movq $1, %%rdi \n\t"
-		"movq %1, %%rsi \n\t"
-		"movl %2, %%edx \n\t"
-		"syscall"
-		: "=g"(ret)
-		: "g"(str), "g" (len));
+        __asm__("movq $1, %%rax \n\t"     // rax = 1 - Specify the number of the system call (1 is `sys_write`).
+                "movq $1, %%rdi \n\t"     // rdi = 1 - Set the first argument of `sys_write` to 1 (`stdout`).
+                "movq %1, %%rsi \n\t"     // rsi = str - Set the second argument of `sys_write` to the reference of the `str` variable.
+                "movq %2, %%rdx \n\t"     // rdx = len(str) - Set the third argument of `sys_write` to the length of the `str` variable's value.
+                "syscall"                 // Call the `sys_write` system call.
+                : "=g"(ret)               // Return the result in the `ret` variable.
+                : "g"(str), "g" (len));   // Put `str` and `len` variables in any general operand (memory, register, or immediate, if possible)
 
-	return 0;
+        printf("Bytes written: %d\n", ret);
+        return 0;
 }

casm/casm3/Makefile

@@ -1,3 +1,7 @@
-build:
+all:
 	nasm -f elf64 -o casm.o casm.asm
 	gcc casm.o casm.c -o casm 
+
+clean:
+	rm -rf *.o
+	rm -rf casm

casm/casm3/casm.asm

@@ -1,15 +1,22 @@
-global printHelloWorld
-
+;; Definition of the text section
 section .text
-printHelloWorld:
-	;; 1 arg
-	mov	r10, rdi
-	;; 2 arg
-	mov	r11, rsi
-	;; call write syscall
-	mov	rax, 1
-	mov	rdi, 1
-	mov	rsi, r10
-	mov	rdx, r11
-	syscall
-	ret
+        ;; Reference to the entry point of our program
+        global my_strlen
+
+;; Function that returns the length of the string passed in the first argument
+my_strlen:
+        ;; Reset the register value to zero. The value will be returned from the
+        ;; function as the result.
+        xor rax, rax
+.loop:
+        ;; Compare the first element in the given string with the `NUL` terminator (end of the string).
+        cmp byte [rdi + rax], 0
+        ;; If we reached the `NUL` terminator, exit from the function.
+        je .done
+        ;; Increase the counter that stores the length of the string.
+        inc rax
+        ;; Repeat the operations above until we reach the end of the string.
+        jmp .loop
+.done:
+        ;; Exit from the function and return the result in the `rax` register.
+        ret

casm/casm3/casm.c

@@ -1,10 +1,15 @@
-#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
 
-extern void printHelloWorld(char *str, int len);
+extern int my_strlen(const char *str);
 
-int main() {
-	char* str = "Hello World\n";
-	int len = strlen(str);
-	printHelloWorld(str, len);
-	return 0;
+int main(int argc, char *argv[]) {
+    if (argc != 2) {
+        fprintf(stderr, "Error: this program must have 1 command line argument\n");
+        return EXIT_FAILURE;
+    }
+
+    printf("The argument length is - %d\n", my_strlen(argv[1]));
+
+    return 0;
 }

content/asm_1.md

@@ -47,7 +47,7 @@ In addition to a Linux machine, you’ll need compilers to build the examples we
 - [NASM](https://nasm.us/)
 - [GNU LD](https://sourceware.org/binutils/docs/ld/)
 
-We will use these three tools in most of the examples. If we need additional tools, I’ll mention them in the relevant example descriptions. You can install GNU GCC, NASM, and GNU LD using your Linux distribution’s package manager. For [Debian](https://www.debian.org/) or [Ubuntu](https://ubuntu.com/)-based distributions, use:
+We will use these three tools in most of the examples. If we need additional tools, I’ll mention them in the relevant example descriptions. You can install GNU GCC, NASM, and GNU LD using your Linux distribution’s package manager. For [Debian](https://www.debian.org/)-based distributions, use:
 
 ```bash
 sudo apt-get install gcc nasm binutils
@@ -142,7 +142,7 @@ Let's write our first assembly program based on this code sample:
 ```assembly
 ;; Definition of the `data` section
 section .data
-    ;; String `msg` variable with the value `hello world!`
+    ;; String variable with the value `hello world!`
     msg db      "hello, world!"
 
 ;; Definition of the text section
@@ -158,11 +158,11 @@ _start:
     mov     rdi, 1
     ;; Set the second argument of `sys_write` to the reference of the `msg` variable.
     mov     rsi, msg
-    ;; Set the third argument to the length of the `msg` variable's value (13 bytes).
+    ;; Set the third argument of `sys_write` to the length of the `msg` variable's value (13 bytes).
     mov     rdx, 13
-
     ;; Call the `sys_write` system call.
     syscall
+
     ;; Specify the number of the system call (60 is `sys_exit`).
     mov    rax, 60
     ;; Set the first argument of `sys_exit` to 0. The 0 status code is success.

content/asm_3.md

@@ -222,7 +222,7 @@ str_to_int:
 	;; Base for multiplication
 	mov rcx,  10
 __repeat:
-	;; Compare the first element in the given string with the NUL terminator (end of the string).
+	;; Compare the first element in the given string with the `NUL` terminator (end of the string).
 	cmp [rsi], byte 0
 	;; If we reached the end of the string, return from the procedure. The result is stored in the rax register.
 	je __return
@@ -435,7 +435,7 @@ str_to_int:
 	;; Base for multiplication
 	mov rcx,  10
 __repeat:
-	;; Compare the first element in the given string with the NUL terminator (end of the string).
+	;; Compare the first element in the given string with the `NUL` terminator (end of the string).
 	cmp [rsi], byte 0
 	;; If we reached the end of the string, return from the procedure. The result is stored in the rax register.
 	je __return

content/asm_4.md

@@ -208,7 +208,7 @@ After that, we need to call the `reverseStringAndPrint` procedure to calculate t
 ```assembly
 ;; Calculate the length of the input string and prepare to reverse it.
 reverseStringAndPrint:
-        ;; Compare the first element in the given string with the NUL terminator (end of the string).
+        ;; Compare the first element in the given string with the `NUL` terminator (end of the string).
         cmp byte [rsi], 0
         ;; Preserve the length of the reversed string in the rdx register. We will use this value when printing the string.
         mov rdx, rcx