Machine-Level Programming VIII: Data Comp 21000: Introduction to Computer Systems & Assembly Lang Spring 2017 Systems book chapter 3* * Modified slides from the book “Computer Systems: a Programmer’s Perspective, 3rd ed.”, Randy Bryant & David O’Hallaron, 2015

Today Arrays Structures One-dimensional Multi-dimensional (nested) Multi-level Structures

Basic Data Types Integral Floating Point Stored & operated on in general (integer) registers Signed vs. unsigned depends on instructions used Intel ASM Bytes C byte b 1 [unsigned] char word w 2 [unsigned] short double word l 4 [unsigned] int quad word q 8 [unsigned] long int (x86-64) Floating Point Stored & operated on in floating point registers Single s 4 float Double l 8 double Extended t 10/12/16 long double

Array Allocation Basic Principle T A[L]; Array of data type T and length L Contiguously allocated region of L * sizeof(T) bytes char string[12]; x x + 12 int val[5]; x x + 4 x + 8 x + 12 x + 16 x + 20 double a[3]; x + 24 x x + 8 x + 16 char *p[3]; x x + 4 x + 8 x + 12 IA32 x x + 8 x + 16 x + 24 x86-64

Array Access Basic Principle Reference Type Value T A[L]; Array of data type T and length L Identifier A can be used as a pointer to array element 0: Type T* Reference Type Value val[4] int 3 val int * x val+1 int * x + 4 &val[2] int * x + 8 val[5] int ?? *(val+1) int 5 val + i int * x + 4 i int val[5]; 1 5 2 3 x x + 4 x + 8 x + 12 x + 16 x + 20

Array Example Declaration “zip_dig cmu” equivalent to “int cmu[5]” #define ZLEN 5 typedef int zip_dig[ZLEN]; zip_dig cmu = { 1, 5, 2, 1, 3 }; zip_dig mit = { 0, 2, 1, 3, 9 }; zip_dig ucb = { 9, 4, 7, 2, 0 }; zip_dig cmu; 1 5 2 3 16 20 24 28 32 36 zip_dig mit; 2 1 3 9 36 40 44 48 52 56 zip_dig ucb; 9 4 7 2 56 60 64 68 72 76 Declaration “zip_dig cmu” equivalent to “int cmu[5]” Example arrays were allocated in successive 20 byte blocks Not guaranteed to happen in general (individual arrays will be consec)

Array Accessing Example zip_dig cmu; 1 5 2 3 16 20 24 28 32 36 int get_digit (zip_dig z, int dig) { return z[dig]; } Register %rdi contains starting address of array Register %rsi contains array index Desired digit at 4*%rsi + %rdi Use memory reference (%rdi,%rsi,4) X86-64 # %rdi = z # %rsi = digit movl (%rdi,%rsi,4), %eax # z[digit]

Referencing Examples Code Does Not Do Any Bounds Checking! zip_dig cmu; 1 5 2 3 16 20 24 28 32 36 zip_dig mit; 9 40 44 48 52 56 zip_dig ucb; 4 7 60 64 68 72 76 Code Does Not Do Any Bounds Checking! Reference Address Value Guaranteed? mit[3] 36 + 4* 3 = 48 3 mit[5] 36 + 4* 5 = 56 9 mit[-1] 36 + 4*-1 = 32 3 cmu[15] 16 + 4*15 = 76 ?? Out of range behavior implementation-dependent No guaranteed relative allocation of different arrays Yes No No No

Array Loop Example (X86-64) void zincr(zip_dig z) { int i; for (i = 0; i < ZLEN; i++) z[i]++; } # %rdi = z movl $0, %eax # i = 0 jmp .L3 # goto middle .L4: # loop: addl $1, (%rdi,%rax,4) # z[i]++ addq $1, %rax # i++ .L3: # middle cmpq $4, %rax # i:4 jbe .L4 # if <=, goto loop ret

Pointer Loop Example (X86-64) void zincr_v(zip_dig z) { void *vz = z; int i = 0; do { (*((int *) (vz+i)))++; i += ISIZE; } while (i != ISIZE*ZLEN); } void zincr_p(zip_dig z) { int *zend = z+ZLEN; do { (*z)++; z++; } while (z != zend); } #define ZLEN 5 #define ISIZE 4 # rdx = z = vz movl $0, %rax # i = 0 .L8: # loop: addl $1, (%rdx,%rax) # Increment vz+i addl $4, %rax # i += 4 cmpl $20, %rax # Compare i:20 jne .L8 # if !=, goto loop

Nested Array Example “zip_dig pgh[4]” equivalent to “int pgh[4][5]” #define PCOUNT 4 zip_dig pgh[PCOUNT] = {{1, 5, 2, 0, 6}, {1, 5, 2, 1, 3 }, {1, 5, 2, 1, 7 }, {1, 5, 2, 2, 1 }}; 1 5 2 6 1 5 2 3 1 5 2 7 1 5 2 zip_dig pgh[4]; 76 96 116 136 156 “zip_dig pgh[4]” equivalent to “int pgh[4][5]” Variable pgh: array of 4 elements, allocated contiguously Each element is an array of 5 int’s, allocated contiguously “Row-Major” ordering of all elements guaranteed

Multidimensional (Nested) Arrays Declaration T A[R][C]; 2D array of data type T R rows, C columns Type T element requires K bytes Array Size R * C * K bytes Arrangement Row-Major Ordering A[0][0] A[0][C-1] A[R-1][0] • • • A[R-1][C-1] • int A[R][C]; • • • A [0] [C-1] [1] [R-1] •  •  • 4*R*C Bytes

Nested Array Row Access Row Vectors A[i] is array of C elements Each element of type T requires K bytes Starting address A + i * (C * K) int A[R][C]; • • • A [0] [C-1] A[0] • • • A [i] [0] [C-1] A[i] • • • A [R-1] [0] [C-1] A[R-1] •  •  • •  •  • A A+i*C*4 A+(R-1)*C*4

Nested Array Row Access Code int *get_pgh_zip(int index) { return pgh[index]; } #define PCOUNT 4 zip_dig pgh[PCOUNT] = {{1, 5, 2, 0, 6}, {1, 5, 2, 1, 3 }, {1, 5, 2, 1, 7 }, {1, 5, 2, 2, 1 }}; // This returns the address of the array that begins at index # %rdi = index leaq (%rdi,%rdi,4),%rax # 5 * index leaq pgh(,%rax,4),%rax # pgh + (20 * index) Row Vector pgh[index] is array of 5 int’s Starting address pgh+20*index X86-64 Code Computes and returns address Compute as pgh + 4*(index+4*index)

Nested Array Row Access Array Elements A[i][j] is element of type T, which requires K bytes Address A + i * (C * K) + j * K = A + (i * C + j)* K int A[R][C]; • • • A [0] [C-1] A[0] • • • • • • A [i] [j] A[i] • • • A [R-1] [0] [C-1] A[R-1] •  •  • •  •  • A A+i*C*4 A+(R-1)*C*4 A+i*C*4+j*4

Nested Array Element Access Code pgh 1 5 2 6 3 7 int get_pgh_digit (int index, int dig) { return pgh[index][dig]; } leaq (%rdi,%rdi,4), %rax # 5*index addl %rax, %rsi # 5*index+dig movl pgh(,%rsi,4), %eax # M[pgh + 4*(5*index+dig)] Array Elements pgh[index][dig] is int Address: pgh + 20*index + 4*dig = pgh + 4*(5*index + dig) X86-64Code Computes address pgh + 4*((index+4*index)+dig)

Strange Referencing Examples 76 96 116 136 156 1 5 2 6 3 7 zip_dig pgh[4]; Reference Address Value Guaranteed? pgh[3][3] 76+20*3+4*3 = 148 2 pgh[2][5] 76+20*2+4*5 = 136 1 pgh[2][-1] 76+20*2+4*-1 = 112 3 pgh[4][-1] 76+20*4+4*-1 = 152 1 pgh[0][19] 76+20*0+4*19 = 152 1 pgh[0][-1] 76+20*0+4*-1 = 72 ?? Code does not do any bounds checking Ordering of elements within array guaranteed Yes Yes Yes Yes Yes No

Multi-Level Array Example Variable univ denotes array of 3 elements Each element is a pointer 4 bytes Each pointer points to array of int’s zip_dig cmu = { 1, 5, 2, 1, 3 }; zip_dig mit = { 0, 2, 1, 3, 9 }; zip_dig ucb = { 9, 4, 7, 2, 0 }; #define UCOUNT 3 int *univ[UCOUNT] = {mit, cmu, ucb}; cmu 1 5 2 3 16 20 24 28 32 36 36 160 16 56 164 168 univ mit 2 1 3 9 36 40 44 48 52 56 ucb 9 4 7 2 56 60 64 68 72 76

Element Access in Multi-Level Array int get_univ_digit (int index, int dig) { return univ[index][dig]; } salq $2, %rsi # 4*dig addq univ(,%rdi,8), %rsi # p = univ[index] + 4*dig movl (%rsi), %eax # return *p ret Computation Element access Mem[Mem[univ+4*index]+4*dig] Must do two memory reads First get pointer to row array Then access element within array

Array Element Accesses Nested array Multi-level array int get_pgh_digit (int index, int dig) { return pgh[index][dig]; } int get_univ_digit (int index, int dig) { return univ[index][dig]; } Accesses looks similar in C, but addresses very different: Mem[pgh+20*index+4*dig] Mem[Mem[univ+4*index]+4*dig]

Strange Referencing Examples 36 160 16 56 164 168 univ cmu 1 5 2 3 20 24 28 32 mit 9 40 44 48 52 ucb 4 7 60 64 68 72 76 Reference Address Value Guaranteed? univ[2][3] 56+4*3 = 68 2 univ[1][5] 16+4*5 = 36 0 univ[2][-1] 56+4*-1 = 52 9 univ[3][-1] ?? ?? univ[1][12] 16+4*12 = 64 7 Code does not do any bounds checking Ordering of elements in different arrays not guaranteed Yes No No No No

N X N Matrix Code Fixed dimensions #define N 16 typedef int fix_matrix[N][N]; /* Get element a[i][j] */ int fix_ele (fix_matrix a, int i, int j) { return a[i][j]; } Fixed dimensions Know value of N at compile time Variable dimensions, explicit indexing Traditional way to implement dynamic arrays Variable dimensions, implicit indexing Now supported by gcc #define IDX(n, i, j) ((i)*(n)+(j)) /* Get element a[i][j] */ int vec_ele (int n, int *a, int i, int j) { return a[IDX(n,i,j)]; } /* Get element a[i][j] */ int var_ele (int n, int a[n][n], int i, int j) { return a[i][j]; }

16 X 16 Matrix Access Array Elements Address A + i * (C * K) + j * K #define N 16 typedef int fix_matrix[N][N]; /* Get element a[i][j] */ int fix_ele(fix_matrix a, int i, int j) { return a[i][j]; } # a in %rdi, i in %rsi, j in %rdx salq $6, %rsi # 64*i addq %rsi, %rdi # a + 64*i movl (%rdi,%rdx,4), %eax # M[a + 64*i + 4*j] ret

n X n Matrix Access Array Elements Address A + i * (C * K) + j * K C = n, K = 4 /* Get element a[i][j] */ int var_ele(int n, int a[n][n], int i, int j) { return a[i][j]; } # n in %rdi, a in %rsi, i in %rdx, j in %rcx imulq %rdx, %rdi # n*i leaq (%rsi,%rdi,4), %rax # a + 4*n*i movl (%rax,%rcx,4), %eax # a + 4*n*i + 4*j ret

Optimizing Fixed Array Access j-th column #define N 16 typedef int fix_matrix[N][N]; /* Retrieve column j from array */ void fix_column (fix_matrix a, int j, int *dest) { int i; for (i = 0; i < N; i++) dest[i] = a[i][j]; } Computation Step through all elements in column j Optimization Retrieving successive elements from single column

Optimizing Fixed Array Access Optimization Compute ajp = &a[i][j] Initially = a + 4*j Increment by 4*N /* Retrieve column j from array */ void fix_column (fix_matrix a, int j, int *dest) { int i; for (i = 0; i < N; i++) dest[i] = a[i][j]; } Register Value %ecx ajp %ebx dest %edx i 1 2 j 4 5 … 3 Address of A[0][j] (initial ajp) Address of A[1][j] is initial ajp + size of row (4*16=64)

Optimizing Fixed Array Access Optimization Compute ajp = &a[i][j] Initially = a + 4*j Increment by 4*N /* Retrieve column j from array */ void fix_column (fix_matrix a, int j, int *dest) { int i; for (i = 0; i < N; i++) dest[i] = a[i][j]; } Register Value %rcx ajp %rbx dest %rdx i .L8: # loop: movl (%rcx), %rax # Read *(ajp) movl %rax, (%rbx,%rdx,4) # Save in dest[i] addl $1, %rdx # i++ addl $64, %rcx # ajp += 4*N cmpl $16, %rdx # i:N jne .L8 # if !=, goto loop

Optimizing Variable Array Access Compute ajp = &a[i][j] Initially = a + 4*j Increment by 4*n /* Retrieve column j from array */ void var_column (int n, int a[n][n], int j, int *dest) { int i; for (i = 0; i < n; i++) dest[i] = a[i][j]; } Register Value %rcx ajp %rdi dest %rdx i %rbx 4*n %rsi n .L18: # loop: movl (%rcx), %rax # Read *ajp movl %rax, (%rdi,%rdx,4) # Save in dest[i] addl $1, %rdx # i++ addl $rbx, %rcx # ajp += 4*n cmpl $rdx, %rsi # n:i jg .L18 # if >, goto loop

Today Procedures (x86-64) Arrays Structures One-dimensional Multi-dimensional (nested) Multi-level Structures Allocation Access

Structure Allocation Memory Layout Concept struct rec { int a[4]; int i; struct rec *next; }; Memory Layout a i next 16 24 32 Concept Contiguously-allocated region of memory Refer to members within structure by names Members may be of different types Fields ordered according to declaration Even if another ordering could yield a more compact representation Compiler determines overall size + positions of fields Machine-level program has no understanding of the structures in the source code

Structure Access r r+16 Accessing Structure Member X86-64 Assembly a i struct rec { int a[4]; int i; struct rec *next; }; a i next 16 24 32 Accessing Structure Member Pointer indicates first byte of structure Access elements with offsets void set_i(struct rec *r, int val) { r->i = val; } X86-64 Assembly # %rdx = val # %rax = r movq %rdx, 16(%rax) # Mem[r+16] = val

Generating Pointer to Structure Member r+4*idx struct rec { int a[4]; int i; struct rec *n; }; a i next 16 24 32 Generating Pointer to Array Element Offset of each structure member determined at compile time Arguments Mem[%ebp+8]: r Mem[%ebp+12]: idx Compute as r + 4*idx int *get_ap (struct rec *r, int idx) { return &r->a[idx]; } # r in %rdi, idx in %rsi leaq (%rdi,%rsi,4), %rax ret

Following Linked List C Code Element i a i next 16 24 32 struct rec { int a[4]; int i; struct rec *next; }; Following Linked List C Code void set_val (struct rec *r, int val) { while (r) { int i = r->i; r->a[i] = val; r = r->next; } a i next 16 24 32 Element i Register Value %rdi r %rsi val .L11: # loop: movslq 16(%rdi), %rax # i = M[r+16] movl %esi, (%rdi,%rax,4) # M[r+4*i] = val movq 24(%rdi), %rdi # r = M[r+24] testq %rdi, %rdi # Test r jne .L11 # if !=0 goto loop

Summary Arrays Structures One-dimensional Multi-dimensional (nested) Multi-level Structures Allocation Access