Hello World in NASM assembly

Objectives

1. Look at the outline of a simple assembly program.
2. Learn how to assemble and link a program on our system.

Notes

• Reference : Jorgensen chapter 4.
• Today we will look at hello.asm.
  • The goal is not complete understanding
  • We are just trying to get the basic concept of assembly programming.
• This is essentially the program

  • const string message = "Hello World!\n";
    const int length = 14;
    int main() {
       write(1, &message;, length);
    
       return 0;
    } 

  • write
    • reference.
    • This man page has an error in the function prototype
    • ssize_t write(int fd, const void buf[count], size_t count);
    • or man 2 write
    • This is a low level system call.
      • cout and the stream insertion operator are based on this.
      • and printf if you know that.
    • We will be using this all semester.
    • It takes
      • A stream (stdout, stderr, file)
      • A pointer to character buffer
      • The length to print
    • And writes that the length characters in that buffer to the stream
• Assembly consists of
  • comments,
    • starts with a ; and ends with a newline
    • ; This is a program
    • mv eax, 60 ; move 60 to the extended e register.
    • Comments, as you will soon see, are exceptionally important in assembly. int fd, const void buf[count], size_t count);
  • Assembly directives.
    • These tell the assembler how to do things.
    • section .data
    • global _start
  • Assembly instructions
    • These are the low level commands of the language mov rsi, message
  • Labels
    • user defined locations in memory.
    • Sort of like variables, but for data and code.
    • message: db "Hello World!",&0x0A (message)
    • global _start (_start, not global, that is a directive)
  • Constants
    • message: db "Hello World!",&0x0A (message)
• Let's go through the code
  • Comments
  • section .data
    • There are conventions for how to put a program into memory
    • Program memory is generally broken down into the following sections
      • data: global variables initialized with a value
      • bss: Uninitialized data or the bss section
      • text: the program commands
      • stack: for function calls
      • heap: for dynamic memory
    • In this data section we declare two "variables"
      • Message holds the values
        "Hello World!"
        And a hex A
      • message: db "Hello World!", 0x0A
        • Message is a label
        • This corresponds to a memory address.
        • db says that we are declaring byte sized memory values
        • This builds the string with a newline at the end.
        • NASM is wierd about adding newlines, so I do it this way.
        • There are other ways too.
      • We can look at this
        • if we run hello with gdb, we can examine this with

        • gdb hello
          // a bunch of text
          break 10      // also b 10
          run           // also r
          x &message   // not what we wanted, but what is happening here?
          x &message/s message 

        • By the way, just for fun, get out and od -x hello
      • message_length: equ $ - message
        • This tells the compiler to compute the value
          • $:current address
          • subtract the address of message
          • Store this in the assembler constant message_length
          • I don't know how to look at this directly.
    • The .text section
      • global _start
        • This says that there will be a _start label
        • Make it global, or expose this label to the outside world.
        • Like main in a c++ program, this tells the OS where to start running the code.
      • _start
        • This actually declares the start address.
      • mov rsi, message
        • This is an assembly command
        • mov is the mnemonic
        • rsi and message are the arguments or operands.
        • It moves the second operand to the first operand
        • In this case, it moves the address of the message to register rsi
        • There is way too much going on here, but remember the write system call.
        • We will study move as we go along, there are many forms.
      • syscall
        • I don't have a great reference, but this table works.
        • For write
          • This calls the system call indicated in rai (1)
          • The file descriptor (1) needs to be in rdi
          • The address of the buffer needs to be in rsi
          • The length of the string needs to be in rdi
        • For exit
          • The system call is 60, rax
          • The argument is 0 (success), rdi