Int
| 종류 | 어셈블리어 | 바이트 | C언어 |
|---|---|---|---|
| byte | b | 1 | char |
| word | w | 2 | short |
| double word | l | 4 | int |
| quad word | q | 8 | long int |
Floating Point
| 종류 | 어셈블리어 | 바이트 | C언어 |
|---|---|---|---|
| single | s | 4 | float |
| double | l | 8 | double |
| extended | t | 10/12/16 | long double |
T A[L] 뜻: type T의 길이 L의 배열 A L*sizeof(T) byte의 연속된 공간에 저장됨.
![p[3]이 8씩인 이유는 주소는 8바이트이기 때문이다.](https://s3-us-west-2.amazonaws.com/secure.notion-static.com/1f563b13-56df-482b-83a8-7db5875f0570/Untitled.png)
p[3]이 8씩인 이유는 주소는 8바이트이기 때문이다.
사용법 ex. int val[5] = {1,5,2,1,3} 시작 주소 = x

| 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) | ||
| 사실 val[1]과 동등 | int | 5 |
| val+i | int* 포인터 | x+4i |
Array Access, Loop Example
#define ZLEN 5
typedef int arr[ZLEN]
int get_digit(arr z, int dig)
return z[dig];
void arrincr(int z[]){
size_t i; //size_t: 시스템에서 최대 크기; x86에서 32비트, 64에서 64비트이다.
for(i=0; i<ZLEN;i++)
z[i]++;
}
Assembly
// %rdi = z, %dsi = dig, %eax: return value
movl (%rdi, %rsi, 4), %eax
// %rdi = z
movl $0, %eax
jmp .L3
.L4:
addl $1, (%rdi, %rax, 4) //z[i]++
addq $1, %rax //i++
.L3:
cmpq $4, %rax //test
jbe .L4 //if i<=4 loop
rep; ret
Pointers and arrays
포인터 배열, (배열) 배열이 구분된다.

Multidimensioanl(Nested) Array (2D) 2D: T A[R][C]

한 행씩, 연속된 공간에 들어간다.
Access ex) int pgh[4][5] = {{1,5,2,0,6},{1,5,2,1,3},{1,5,2,1,7},{1,5,2,2,1}}; R = 4, C= 5, K = 4

Row Vector A[i]
//pgh[4][5]의 pgh[i] 접근
//%rdi = index
leaq (%rdi, %rdi, 4), %rax //i*C
leaq pgh(,%rax,4), %rax //((i*C)*K)+pgh
//포인터 반환이므로 leaq사용
Element A[i][j]
//%rdi = i, %rsi = j
leaq (%rdi, %rdi, 4), %rax //i*C
addl %rax, %rsi //i*C+j
movl pgh(,%rsi,4), %eax //*(arr+(i*C+j)*K) == arr[i][j]
//값 반환이므로 movl 사용
Multi-Level Array

int *arr[3] = {mit, cmu, ucb}
위의 예시(Nested)와 다르게 주소가 연속적이지 않을 수 있다.
각 row vector은 포인터이다.
Element Access
//%rdi = i, %rsi = j
salq $2, %rsi //비트시프트 레프트 2칸 = 4*j
addq arr(,%rdi,8), %rsi //arr[i]+4*j
movl (%rsi), %eax //*(arr[i]+4*j) == arr[i][j] 반환
ret

Fixed Dim
#define N 16
typedef int fix_mat [N][N]
int func(fix_mat a, size_t i, size_t j)
return a[i][j];
//%rdi = a, %rsi = i, %rdx = j
//A+i*C*K+j*k
//C=16, j=4
salq $6, %rsi //shift left : 2^6*i = 64*i
addq %rsi, %rdi //a+64*i
movl (%rdi, %rdx, 4), %eax //M[a+64*i+4*j]
//또는...
leaq (%rsi , %rsi , 15), %rax //i*16
addl %rax, %rdx //i*16+j
movl pgh(,%rsi,4), %eax //M[a+(i*16+j)*4]
Variable Dim, Explicit Indexing
int func(int *a, size_t n, int i, int j)
return a[(i*n+j)]
Variable Dim, Implicit Indexing
int func(size_t n, int a [n][n], int i, int j)
return a[i][j]
//%rdi = n, %rsi = a, %rdx = i , %rcx = j
imulq %rdx, %rdi //n*i
leaq (%rsi, %rdi, 4), %rax //a+4*n*i
movl (%rax, %rcx, 4), %eax //M[a+4*n*i+4*j]
구조체 = block of memory

Generating Pointer
Structure Alignment