Basic Data Types

• Int

  • stored in general registers

  종류	어셈블리어	바이트	C언어
  byte	b	1	char
  word	w	2	short
  double word	l	4	int
  quad word	q	8	long int

• Floating Point

  • stored in floating point registers

  종류	어셈블리어	바이트	C언어
  single	s	4	float
  double	l	8	double
  extended	t	10/12/16	long double

Arrays in Assembly

• T A[L] 뜻: type T의 길이 L의 배열 A L*sizeof(T) byte의 연속된 공간에 저장됨.

  

  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]

  • size: RCK
  • memory arrangement

  

  한 행씩, 연속된 공간에 들어간다.

  • 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]

      • A[i]에는 C개씩 들어가 있다
      • 따라서 A+i*(C*K)로 접근

      //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]

      • A+i*(CK) + jK = M[A+(i*C+j)*K]

      //%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

    • arr[i][j] : M[M[arr+i8]+jK] 8인 이유는 포인터는 8바이트이기 때문. K는 4이다(int)

    //%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
    

• Matrix Codes

  • 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]
    

Structures

• 구조체 = block of memory

  

  • 선언 순서에 따라 배치
  • 컴파일러가 전체 크기와 각 필드의 크기 결정

• Generating Pointer

  • 최소 4바이트*index씩 움직인다(1 word)

• Structure Alignment

  • B byte primative data type(원시 자료형; int나 bool같은거) : 주소가 B의 배수여야 함!!!!
    • 1 byte: char
    • 2 bytes: short
    • 4 bytes: int, float
    • 8 bytes: double, long, char*, pointer
    • 16 bytes: long double
  • 전체 주소는 가장 큰 B의 배수여야 함!!!
  • ex. struct s { char c; int i[2]; double v; } * p;
  • structure array 계산된 구조체의 크기의 배수+오프셋 이렇게 접근
  • 최적화 방법

Floating Points

• History