As a second example, the goal is to write inline assembler code, that takes a string as input, and calculates the length of the string. Recall that strings in C are represented as arrays of char and each char has a size of 1 byte. Make sure to use the correct assembler-load instruction to get the next character. Strings are terminated by the \0 (the value 0, not the symbol 0), which doesn’t count as part of the string. To test the result, you can compare it with the result of the libc function strlen or with the C function presented in an earlier class.

Here's an example of inline assembler code that calculates the length of a string:

#include <stdio.h>

int main() {
    char str[] = "Hello, world!";
    int len;

    asm volatile (
        "movl $0, %0\n\t"    // initialize counter to 0
        "1:\n\t"
        "movb (%1), %%al\n\t"   // load next character into al
        "cmpb $0, %%al\n\t"     // compare with null terminator
        "je 2f\n\t"             // if equal, jump to end
        "incl %0\n\t"           // increment counter
        "incl %1\n\t"           // increment pointer
        "jmp 1b\n\t"            // jump to beginning of loop
        "2:\n\t"
        : "=r" (len)            // output: len = counter
        : "r" (str)             // input: str = pointer to string
        : "%eax"                // clobbered register: eax
    );

    printf("Length of string: %d\n", len);
    return 0;
}

Explanation:
- The `asm volatile` statement tells the compiler that this is inline assembler code that may modify registers and memory, and that it should not optimize or reorder instructions.
- The `movl $0, %0` initializes the counter to 0 and assigns it to the output variable `len`.
- The label `1:` marks the beginning of a loop that processes each character of the string.
- The `movb (%1), %%al` instruction loads the next character into the `al` register.
- The `cmpb $0, %%al` instruction compares the character with the null terminator.
- The `je 2f` instruction jumps to the label `2:` if the character is a null terminator.
- The `incl %0` instruction increments the counter.
- The `incl %1` instruction increments the pointer to the next character.
- The `jmp 1b` instruction jumps back to the beginning of the loop.
- The label `2:` marks the end of the loop.
- The output operand `=r` (len) tells the compiler that `len` is an output variable that will be stored in a register.
- The input operand `"r" (str)` tells the compiler that `str` is an input variable that will be stored in a register.
- The clobbered register `%eax` tells the compiler that the `eax` register may be modified by the inline assembler code.