Arrays, Address Arithmetic, and Strings

For example, we can put full 64-bit numbers into memory using "dq", and then read them back out with QWORD[yourLabel].

Address Arithmetic

If you allocate more than one constant with dq, they appear at ascending addresses.  So this reads the 5, like you'd expect:

dos_equis:
	dq 5   ; writes this constant into a "Data Qword" (8 byte block)
	dq 13  ; writes another constant, at [dos_equis+8] (bytes) 

foo:
	mov rax, [dos_equis] ; read memory at this label
	ret

(Try this in NetRun now!)

Adding 8 bytes (the size of a dq, 8-byte / 64-bit QWORD) from the first constant puts us directly on top of the second constant, 13:

dos_equis:
	dq 5   ; writes this constant into a "Data Qword" (8 byte block)
	dq 13  ; writes another constant, at [dos_equis+8] (bytes)

foo:
	mov rax, [dos_equis+8] ; read memory at this label, plus 8 bytes
	ret

(Try this in NetRun now!)

Accessing an Array

An "array" is just a sequence of values stored in ascending order in memory.  If we listed our data with "dq", they show up in memory in that order, so we can do pointer arithmetic to pick out the value we want.  This returns 7:

mov rcx,my_arr ; rcx == address of the array
mov rax,QWORD [rcx+1*8] ; load element 1 of array
ret

my_arr:
  dq 4 ; array element 0, stored at [my_arr]
  dq 7 ; array element 1, stored at [my_arr+8]
  dq 9 ; array element 2, stored at [my_arr+16]

(Try this in NetRun now!)

mov rcx,my_arr ; rcx == address of the array
mov eax,DWORD [rcx+1*4] ; load element 1 of array
ret

my_arr:
  dd 0xaaabbbcc ; array element 0, stored at [my_arr]
  dd 0xc001007  ; array element 1, stored at [my_arr+4]

(Try this in NetRun now!)

mov rcx,my_arr ; rcx == address of the array
mov eax,[rcx] ; load element 0 of array (OOPS!  32-bit load!)
ret

my_arr:
  dw 0xaabb ; array element 0, stored at [my_arr]
  dw 0xbeef ; array element 1, stored at [my_arr+2]

(Try this in NetRun now!)

mov rcx,my_arr ; rcx == address of the array
mov eax, WORD [rcx] ; load element 0 of array (OOPS!  32-bit load!)
ret

my_arr:
  dw 0xaabb ; array element 0, stored at [my_arr]
  dw 0xbeef ; array element 1, stored at [my_arr+2]

(Try this in NetRun now!)

Loading from the wrong place, or loading the wrong amount of data, is an INCREDIBLY COMMON problem when using pointers, in any language.  You WILL make this mistake at some point over the course of the semester, so be careful!

C Strings in Assembly 

In plain C, you can put a string on the screen with the standard C library "puts" function:

puts("Yo!");

(Try this in NetRun now!)

You can expand this out a bit, by declaring a string variable.  In C, strings are stored as (constant) character pointers, or "const char *":

const char *theString="Yo!";
puts(theString);

(Try this in NetRun now!)

Internally, the compiler does two things:

• Allocates memory for the string, and initializes the memory to  'Y', 'o', '!', and a special zero byte called a nul terminator that marks the end of the string.
• Points theString to this memory.

In assembly, these are separate steps:

• Allocate memory with the db (Data Byte) pseudo instruction, and store characters there, like    db `Yo!`,0
• Unlike C++, you can declare a string using any of the three quotes: "doublequotes", 'singlequotes', or `backticks` (on your keyboard beneath tilde ~)
• However, newlines like \n ONLY work inside backticks, an odd peculiarity of the assembler we use (nasm).
  
• Note we manually added ,0 after the string to insert a zero byte to terminate the string. 
  
• If you forget to terminate the string, puts can print neat garbage after the string until it hits a 0.
  
• Point at this memory using a jump label, just like we were going to jmp to the string.

Here's an example:

mov rdi, theString ; rdi points to our string
extern puts  ; declare the function
call puts    ; call it
ret

theString:    ; label, just like for jumping
	db `Yo!`,0  ; data bytes for string (don't forget nul!)

(Try this in NetRun now!)

In assembly,  there's no obvious way to tell the difference between a label designed for a jump instruction (a block of code), a label designed for a call instruction (a function), a label designed as a pointer (like a string), or many other uses--it's just a pointer!

Strings as Arrays

    while (*p++!=0) { /* do something to *p   */ }

If you unpack this a bit, you find:

• p points to the first char in the string.
• *p is the first char in the string.
• p++ adds 1 to the pointer, moving to the next char in the string.
• *p++ extracts the first char, and moves the pointer down.
• *p++!=0  checks if the first char is zero (the end of the string), and moves the pointer down
  

Here's a typical example, in C:

char s[]="string";   // declare a string
char *p=s;           // point to the start
while (*p++!=0) if (*p=='i') *p='a';  // replace i with a
puts(s);

(Try this in NetRun now!)

Here's a similar pointer-walking trick, in assembly:

mov rdi,stringStart
again:
	add rdi,1 ; move pointer down the string
	cmp BYTE[rdi],'a' ; did we hit the letter 'a'?
	jne again  ; if not, keep looking

extern puts
call puts
ret

stringStart:
	db 'this is a great string',0

(Try this in NetRun now!)