중간고사대비

족보 분석

16년

기본상식(instruction step, 레지스터, 인접짝수, 스택메모리, 플래그레지스터, 엔디안)

부동소수점 만들기(s, E, M, exp, frac, %f표시)

프로시저 인스트럭션 (%rsp, %rip, %rax, %rsi, 프로우와 데이터의 보존, 비어있는 인스트럭션 채우기, 스택 그리기, 해당 인스트럭션이 필요한 이유)

루프 인스트럭션 (C코드 변환 for→while, while→dowhile 등, 반복문 if goto문으로 바꾸기 “중간으로점프”, 비어있는 인스트럭션 채우기, “중간으로 점프” 사용하는 이유설명)

스위치 인스트럭션 (GDB/메모리덤프로 switch문 추적하기)

보안취약성 (어떤 경우 문제가 발생할 수 있는가)

14년

기본상식(instruction step, 오버플로조건, ret시 발생하는 일, if else보다 switch가 유리한점?, 리틀엔디안 판별기)

패트리엇 미사일 예제(책에있는거 그대로 + 인접짝수로 계산시 어떻게되나)

swap 인스트럭션(C코드로 채우기, instruction으로 채우기)

2

CPU : ALU(arithmetic and logic unit)(execution), Control unit(decode), register(PC, 메모리주소/데이터, 범용 등), IO

명령 주기 : fetch → decode → execution → store

OS : HW를 효율적으로 사용하도록 도와주는 system program. HW의 추상화. 프로세스, 메모리, 입출력장치 , 소프트웨어자원

성능개선, 에러이해를 위해 컴파일과정을 아는것이 좋다.

Computer = HW + SW(System SW, Application SW)

3

시스템 프로그래밍에서의 word = 32bit = 4byte

byte ordering 으로 인해 주소체계는 word길이만큼 증가한다

하위→상위주소로 기록한다.

big endian → MSB부터 LSB로 기록한다. 낮은주소에 높은주소부터

little endian → LSB부터 MSB로 기록한다. 낮은주소에 낮은주소부터

ex) [MSB] 0x01234567 [LSB] big endian → [하위] 01 23 45 67 [상위] little endian → [하위] 67 45 23 01 [상위]

생각해봐, 스택은 높은 주소에서 낮은 주소로 늘어나. 그럼 쓰이는건 낮은주소에서 높은주소로 쓰이겠지? big endian은 큰 주소로 끝난다고 하는데, 끝나는 곳이 어디겠어? 마지막에 쓰이는 곳 이겠지? 그래서 빅 엔디안 : 끝에 MSB가 온다 → 최상위가 MSB다. 리틀엔디안도 마찬가지다 리틀 엔디안 : 끝에서 LSB가 온다 → 최상위가 LSB이다.

비트연산자는 논리연산자와 다르다.

practice 1 : 0x39A7F8 = 0011 1001 1010 0111 1111 1000(2) 1100 0011 0101 0001(2) = 0xC351 255(10) = 1111 1111(2) 0x010E = 16^0 * 14 + 16^2 * 1 = 14 + 256 = 270(10)

practice 2 : 01101001 & 01010101 = 01000001 01101001 | 01010101 = 01111101 01101001 ^ 01010101 = 00111100 ~ 01010101 = 10101010

shift는 bit 를 이동시킨다 «, » 일반적으로 빈자리를 0으로 채우는데, »시 MSB를 보존하는 산술 shift도 있다. 이를 부호확장이라고 함. shift의 크기가 음수이거나 한dmㅑword보다 큰경우 컴퓨터가 미친다

practice 3 : 0110 0011 « 4 = 0011 0000 1001 0101 « 4 = 0101 0000 0110 0011 » 4 (logical) = 0000 0110 1001 0101 » 4 (logical) = 0000 0101 0110 0011 » 4 (arithmetic) = 0000 0110 1001 0101 » 4 (arithmetic) = 1111 1001

practice 4 : func : show_byte(pointer, size) → 사이즈번만큼 한바이트씩 끊어서 주소랑 데이터를 보여줌 int val = 0x87654321; byte_pointer valp = (byte_pointer) &val; show_byte(valp, 1); → A : 4321 show_byte(valp, 2); → B : 654321 A. little endian : 21 43, big endian : 43 21 B. little endian : 21 43 65, big endian : 65 43 21

BCD : 4비트로 0~9까지 나타냄 각 자리수마다 4비트씩 → 존나게 비효율적

부호-크기 : MSB로 오직 부호만 나타내고 나머지로 값나타냄

unsigned : 부호없이 그냥 전부 비트가 수를 나타냄 (0 ~ 2^w -1)

signed : 2의 보수를 주로 사용함 비트뒤집고 1더하기 →결과적으로 MSB가 곧 부호임 (-2^(w-1) ~ 0 ~ 2^(w-1) -1)

크기 값 제한에 대해서는 C기준 limits.h에 상수로 지정되어있다. 기기마다 값이 달라지니 이걸 이용해서 문제를피함.

Practice 5 : 0x51 = 0101 0001 → unsigned : 81, signed : 81 0xD9 = 1101 1001 → unsigned : 9 + 13 * 16 = 208 + 9 = 217, signed : 217 - 128 = 89

signed 와 unsigned 는 implicit한 변환이 가능하다

계산시 signed와 unsigned의 충돌이 발생하면 Unsigned 로 통일하여 다룬다

덧셈시 최상위 비트를 넘어서는 캐리가 발생하면 캐리를 날린다 (mod 2^w)

음+음 = 양, 양+양 = 음 발생시 overflow가 발생한 것.

practice 6 :

    int tadd_ok(int x, int y){
    	if(x >= 0 && y >= 0)
    		return ((x + y) >= 0) ? 1 : 0;
    	else if(x < 0 && y < 0)
    		return ((x + y) < 0) ? 1 : 0;
    	else
    		return 1;
    }

practice 7 : -2147483647-1 == 2147483648U → type : unsigned int, evaluation : 1 -2147483647-1 < 2147483647 → type : signed int, evaluation : 1 -2147483647-1U < 2147483647 → type : unsigned int, evaluation : 0 -2147483647-1 < -2147483647 → type : signed int, evaluation : 1 -2147483647-1U < -2147483647 → type : unsigned int, evaluation : 0

4

2진 부동소수점 표현도 10진수랑 방식이 똑같다. 분수부를 아무리합쳐봐야 정수가 안됨 그 미묘한 차이가 엡실론

x*2^y형태로 모든 수를 표현해야하므로 10진수의 0.33333… 같은 표현할 수 없는 수가 발생

practice 1 : 0.010(2) = 2/8 = 0.25(10) 0.0011(2) = 3/16 = 0.1875(10) 0.0011010(2) = 26/128 tip)분수부는 1/2로시작해서 »할수록 1/2^n이되고 정수부는 끝에서부터 1로시작해서 «할수록 2^k된다

practice 2 : 0.75(10) = 3/4 = 0.11(2) 25/16 = 1.1001(2) tip)곱하기를 계속해서 정수부를 제거해가는게 소수 bit가 된다.

practice 3 : 0.1초는 0.0001100110011001100110011001100110011…. 컴푸터에서는 23자리까지밖에 못함. 0.000110011001100110011 오차 발생 0.0000000000000000000011001100110011…. = 9.54 * 10^-8 100시간 = 6000분 = 360000초 = 3600000*0.1초 발생한 시간오차 = 3600000 * 9.54 * 10^-8 = 36 * 9.54 * 10^-3 = 0.34344 초속 2000m이므로 2000m/s * 0.34344s = 686.88m

floating point expression : s M E (-1)^sM2^E,

float : s = 1bit, exp = 8bit, frac = 23bit

double : s = 1bit, exp = 11bit, frac = 52bit

정규화 : exp = E + bias (bias = 2^(e-1) -1 = 127 or 1023), E = -126~127, -1022~1023, frac은 첫비트 1보장.

ex) 15213(10) = 11101101101101(2) = 1.1101101101101(2) → E = 13, frac = 1101101101101, s = 0 exp = E + bias = 13 + 127 = 140 = 1000 1100(2) frac = 110 1101 1011 0100 0000 0000(2) s = 0 → 0 1000 1100 110 1101 1011 0100 0000 0000 → 0100 0110 0110 1101 1011 0100 0000 0000

비정규화 : exp = 0, E = 1 - bias (-126 or -1022), frac은 첫 비트 0

→ frac = 0 : 0을 나타냄. s에따라 음의 0 양의 0이 나뉨

→ frac ≠ 0 : 0에 매우 근접한 소수값을 표시. 위에서 E는 -126이었듯 표현할 수 있는 가장 작은 자릿수를 나타냄 거의 Epsilon?

특수값 : exp = 111…1, E나 bias는 필요없음 애초에 수가 아님.

→ frac = 0 : 무한대를 나타냄. s에 따라 음의 무한대 양의 무한대로 나뉨

→ frac ≠ 0 : 숫자가 아님, Not a Number → NaN

Practice 4 : -15213.0(10) = negate(11 1011 0110 1101(2)) = negate(1.1 1011 0110 1101(2) * 2^13) → s = 1, frac = 1 1011 0110 1101 0000 0000 00, E = 13, exp = E + bias = 13 + 127 = 140 = 1000 1100(2) → 1 1000 1100 1 1011 0110 1101 0000 0000 00 → 1100 0110 0110 1101 1011 0100 0000 0000 9.6875(10) = 1001.1011(2) = 1.0011011(2) * 2^3 → s = 0, exp = 3 + 127 = 130 = 1000 0010(2), frac = 0011 0110 0000 0000 0000 000 → 0 1000 0010 0011 0110 0000 0000 0000 000 →0100 0001 0001 1011 0000 0000 0000 0000

8비트 예시

s = 0, exp = 0000, frac = 000이면 → 비정규화 E = -6 value = 0

s = 0, exp = 0000, frac = 001이면 → 비정규화 E = -6, 0.000000001 = 1/512

s = 0, exp = 0000, frac = 010이면 → 비정규화 E = -6, 0.000000010 = 2/512

…

s = 0, exp = 0000, frac = 111이면 → 비정규화 E = -6, 0.000000111 = 7/512

s = 0, exp = 0001, frac = 000이면 → 정규화 E = exp - 7 = -6, 1.000 → 0.000001000 = 8/512

s = 0, exp = 0001, frac = 001 → E = -6, 1.001 → 0.000001001 = 9/512

s = 0, exp = 0001, frac = 010 → E = -6, 1.010 → 0.000001010 = 10/512

…

s = 0, exp = 1110, frac = 111 → E = 7, 1.111 → 1111 0000 = 128 + 64 + 32 + 16 = 240

s = 0, exp = 1111, frac = 000 → 특수 infinite

s = 0, exp = 1111, frac ≠ 000 → 특수 NaN

헷갈린것 bias = 2^(e-1) -1 exp = E + bias(normal), 1 - bias(denormal) frac = 0 → infinite (special)

라운딩(근사) : 값을 계산해서 frac필드에 알맞게 값을 조절한다 인접짝수 사용 ← 근접한 짝수로 간다

다른 근사방법으로 0방향 올림 내림 반올림 등..

인접 짝수 : 중간에 끼어있을 때 가까운 짝수로 간다. 그게 아니면 걍 반올림.

ex) 1/4자리에서 근사 10.00 011(2) → 중간에 안낌 → 반올림 → 10.00(2) 10.00 110(2) → 중간에 안낌 → 반올림 → 10.01(2) 10.11 100(2) → 중간에 낌 → 인접짝수는? → 11.00(2) 10.10 100(2) → 중간에 낌 → 인접짝수는? → 10.10(2) ex) floating point 수 만들기 128 = 1000 0000 = 1.000 0000 * 2^7 → s = 0, E = 7, M = 1.000 0000 → s = 0, exp = 7 + 7 = 14 = 1110 , frac = 000 → 0111 0000 13 = 0000 1101 = 1.101 * 2^3 → s = 0, exp = 3 + 7 = 10 = 1010, frac = 101 → 0101 0101 17 = 0001 0001 =1.0001 * 2^4 → s = 0, exp = 4 + 7 = 11 = 1011, M = 1.0001 = 1.000, frac = 000 → 0101 1000 19 = 0001 0011 = 1.0011 * 2^4 → s = 0, exp = 4 + 7 = 11 = 1011, M = 1.0011 = 1.010, frac = 010 → 0101 1010 138 = 1000 1010 = 1.0001010 * 2^7 → s = 0, exp = 7 + 7 = 14 = 1110, M = 1.0001010 = 1.001, frac = 001 → 0111 0001 63 = 0011 1111 = 1.11111 * 2^5 → s = 0, exp = 5 + 7 = 12 = 1100, M = 1.11111 = 10.000 → s = 0, exp = 6 + 7 = 13 = 1101, M = 1.000, frac = 000 → 0110 1000

practice 5 : 10.010(2) → 10.0(2) : 중간에 걸쳤다. 내려야 짝수다. 10.011(2) → 10.1(2) : 중간에 안걸침. 반올림에따라 올린다. 10.110(2) → 11.0(2) : 중간에 걸쳤다. 올려야 짝수다. 11.001(2) → 11.0(2) : 중간에 안걸침. 반올림에따라 내린다.

practice 6 : 10.010 = 1.0010 * 2^1 → s = 0, exp = 1 + 7 = 8 = 1000, M = 1.0010, frac =001 → 0100 0001 10.011 = 1.0011 * 2^1 → s = 0, exp = 1 + 7 = 8 = 1000, M = 1.0011, frac = 010 → 0100 0010 10.110 = 1.0110 * 2^1 → s = 0, exp = 1 + 7 = 8 = 1000, M = 1.0110, frac = 011 → 0100 0011 11.001 = 1.1001 * 2^1 → s = 0, exp = 1 + 7 = 8, = 1000, M = 1.1001, frac = 100 → 0100 0100

5

어셈블리어 : 기계어와 1:1 대응관계를 갖는 low level 언어. 데이터타입/연산 모두 기초적.

C코드 변환 과정 : C파일 -컴파일러(gcc -Og -S *.c)→ s(어셈블리)파일 -어셈블러→ o(오브젝트, 바이너리)파일 -링커(파일상호간 참조/라이브러리연결)→ 실행가능한프로그램

disassemble : objdump 를 이용하거나 gdb를이용한다.

시스템프로그래밍에서 워드는 16비트(2바이트)이다. 쿼드워드는? 16*4 = 64 = 8바이트

레지스터는 64바이트 (쿼드워드)길이를 갖고, 하위호환성을위해 각 32비트, 16비트, 8비트, 4비트로 나뉜다.

operand : immediate $xxx, Register %xxx, Memory (%xxx)

컴구의 instruction과는 좀 다르다. instruction src, dst가 기본! 밤랩에서 했던 그대로다

movq $0x4, %rax → %rax레지스터에 0x4값을 복사 movq $-147, (%rax) → %rax레지스터가 가리키는 메모리공간에 -147을 복사 %rax에 들어있는 값이 주소인경우 movq %rax, %rdx → %rdx레지스터에 %rax레지스터에 있는 내용일 복사 movq %rax, (%rdx) → %rdx레지스터가 가리키는 메모리공간에 %rax레지스터에 있는 내용을 복사 movq (%rax), %rdx → %rdx레지스터에 %rax 레지스터가 가리키는 메모리공간에 있는 내용을 복사

레지스터 주소가 들어있고 거기에 괄호를 씌우면 그건 그 레지스터가 저장하고있는 주소의 메모리공간을 의미한다!!!!

메모리 주소 지정 모드 : D(Rb, Ri, S) = (Rb) + s * (Ri) + D 주소에 들은 값을 계산하는거! 단순 메모리지정모드는 offset만 있는거

ex) 0x8(%rdx) = 0xf000 + 0x8 = 0xf008 (%rdx, %rcx) = 0xf000 + 0x0100 = 0xf100 (%rdx, %rcx, 4) = 0xf000 + 4 * 0x0100 = 0xf000 + 0x0400 = 0xf400 0x80(, %rdx, 2) = 0x80 + 2 * %rdx = 0x80 + 0x1e000 = 0x1e080 물론 안에 주소가 있었으면 주소계산이지만 그냥 값이들어있는 경우도 연산됨 RI에 RSP는 올 수 없다!!! D랑 S 는 1, 2, 4, 8이온다..!?

leaq : src로 메모리지정모드받고 그걸로 계산된걸 dst로 보낸다

addq랑 다른건 src가 무조건 주소모드로 표현된 값이 들어와야 한다는점이다.

항상 쓸 수 있는 건 아닌게, 위에서 말했듯 몇가지 제약상황등이 있음 D랑 s는 0 1 2 4 8만와야하고 rsp가 올수는 없다던지..

주소 계산 예제 %rdx = 0xf000 %rcx = 0x0100 0x8(%rdx) = 0x8 + 0xf000 = 0xf008 (%rdx, %rcx, ) = 0xf000 + 0x0100 = 0xf100 (%rdx, %rcx, 4) = 0xf000 + 0x0100 * 4 = 0xf400 0x80(, %rdx, 2) = 0x80 + 0xf000 * 2 = 0x1e080

incq, decq, negq, notq 등 1오퍼랜드 연산자도 있다.

imul은 signed multiplication이고 mul은 unsigned이다.

6

레지스터 : 임시데이터 %rax…, 스택포인터 %rsp, 현재PC %rip, 테스트값 CF, ZF, SF, OF

CF carry flag, ZF zero flag, SF sign flag, OF overflow flag

가장 최근의 연산의 결과에따라 테스트값이 변경된다. carry, zero, signed, overflow 등 (꼭 저장되는 연산이 아니더라도)

cmpq src2, src1 : src1 - src2를 수행함 플래그 결정

testq src2, src1 : src2 & src1을 수행해 플래그 결정

둘 다 값이 실제로 변경되는건 아님

위의 비교와 플래그를 이용해 목적지 레지스터의 값도 변경할 수 있음. set인스트럭션

set인스트럭션은 한 바이트를 00000000 혹은 00000001로만듬. 딱 한바이트만.

sete 같으면 setne 다르면 sets signed이면 즉 음수이면 setns signed가 아니면 즉 양수이면 setge 크거나 같으면 setl 작으면 setle 작거나 같으면 seta 이상이면 setb 이하면

    cmpq %rsi, %rdi            //rdi가 앞에오는 비교자임 
    setg %al                   //rdi > rsi이면 set
    movzbl %al, %eax
    ret

rsi rdi를 비교 (rdi값 - rsi값 해서) rdi가 크면 al의 하위 1비트를 set 그렇게 set된 바이트를 rax로 옮겨서 zero extension 이렇게 하려고 movzbl을 쓰는거임 애초에 al이랑 rax는 같은 레지스터임. 범위가 다른거지. zero extension하려고 이렇게 쓴거임

set인스트럭션이랑 조금 달르게 결과를 기록하는게아니라 그거로 바로 분기하는 jump도있음. jump는 플래그 컨디션이 변경되면 그를 기준으로 어떻게 행동할지를 결정함.

jmp 무조건분기 je 같으면 jne 다르면 js 음수이면 jns 양수이면 jg 크면 jge 크거나같으면 jl 작으면 jle 작거나같으면 ja 이상이면 jb 이하면

    long absdiff(long x, long y){
    	long result;
    	if(x > y)
    		result = x - y;
    	else
    		result = y - x;
    	return result;
    }
    
    다음과 같이 goto문을 통해 변형될 수 있다.
    
    long absdiff(long x, long y){
    	long result;
    	int ntest = x <= y;
    	if(ntest) goto else;
    	result = x - y;
    	goto done;
    else : 
    	result = y - x;
    done : 
    	return result;
    }

    %rdi = x
    %rsi = y
    %rax = return value
    
    absdiff : 
    	cmpq %rsi, %rdi
    	jle else
    	mov %rdi, %rax
    	sub %rsi, %rax
    	ret
    else :
    	mov %rsi, %rax
    	sub %rdi, %rax
    	ret

인스트럭션 src, dst

jx Label : 조건에 따라 코드의 실행 위치가 변한다.

C언어의 goto문을 이용해 jump하는것과 유사하게 동작한다.

cmovX : jmp보다는 cmovx를 사용한다. → jmp쓰면 파이프라인꼬여서 비효율적

    absdiff:
    	movq %rdi, %rax    //rdi가 x임 rax에 임시저장
    	subq %rsi, %rax    //rax(x)에서 rsi(y)를 뺀걸 rax(x - y)에 저장
    	movq %rsi, %rdx    //rsi(y)를 rdx에 저장
    	subq %rdi, %rdx    //rdx(y)에서 rdi(x)를 빼서 rdx(y - x)에 저장
    	cmpq %rsi, %rdi    //rdi(x)랑 rsi(y)를 비교해서
    	cmovle %rdx, %rax  //x가 y보다 작거나 같다면 rdx(y - x)를 rax에 저장
    	ret

//일단 둘 다 계산해놓고 어떤걸 rax(리턴위치)에 줄 지 선택하는 방식. 

jmp쓰면 흐름이 꼬이니 걍 cmovx를 쓰는거. 일단 다 계산하고 뭐 반환할지만 결정.

do while문

    long pcount_dowhile(unsigned long x){
    	long result = 0;
    	do{
    		result += x & 0x1;
    		x >>= 1;
    	} while(x);
    	return result;
    }
    
    long pcount_goto(unsigned long x){
    	long result = 0;
    Loop : 
    	result += x & 0x1;
    	x >>= 1;
    	if(x) goto Loop;
    	return result;
    }

    pcount_assembly :
    	movl $0, %eax        //%eax는 result
    Loop :
    	movq %rdi, %rdx      //인자로 받은 rdi를 rdx로 옮겨줌
    	andl $1, %rdx        //1이랑 and연산
    	addq %rdx, %rax      //result에 더한값 저장
    	shrq %rdi            //shift right q 한 연산의 결과가 플래그에 반영됨
    	jne Loop             //그 결과가 0이 아니라면 반복
    	rep; ret

일반적인 while문

중간 으로 점프 형태!!!!!

    long pcount_while(unsigned long x){
    	long result = 0;
    	while(x){
    		result += x & 0x1;
    		x >>= 1;
    	}
    	return result;
    }
    
    //while -> do while
    long pcount_dowhile(unsigned long x){
    	long result = 0;
    	if(!x) goto done;
    	do{
    		result += x & 0x1;
    		x >>= 1;
    	}while(x);
    done :
    	return result;
    }
    
    //do while -> goto
    long pcount_goto(unsigned long x){
    	long result = 0;
    	if(!x) goto done;
    loop : 
    	result += x & 0x1;
    	x >>= 1;
    	if(x) goto loop;
    done :
    	return result;
    }
    
    //or just..
    long pcount_goto(unsigned long x){
    	long result = 0;
    	goto Test;
    Loop : 
    	result += x & 0x1;
    	x >>= 1;
    Test : 
    	if(x) goto Loop;
    	return result;
    }

    pcout_assembly : 
    	movq $0, %eax
    	jmp Test
    Loop :
    	movq %rdi, %rdx
    	andq $1, %rdx
    	addq %rdx, %rax
    	shrq %rdi
    Test :
    	testq $0, %rdi
    	jne Loop

어셈블리는 내가 작성한거라 정확한거 아님!!!! 일반적으로 do while문으로 번역해서 go to로 변환

왜 중간으로 점프를 사용하는건가요? use the same loop structure as we saw for do-while loops but differ in how to implement the initial test. 일단 unconditional jump로 test를 거쳐서 loop로 간다ㅅ

    //while
    while(test)
    	body

    //while->do while 
    if(!test) goto done;
    do
    	body
    	whie(test);
    done:

    //do while->if 
    if(!test) goto done;
    loop :
    	body
    	if(test) go to loop;
    done:

    goto test
    loop : 
    	body
    test :
    	goto loop;
    done : ...

for문은 while로 변환해서 동일하게 처리해준다..

    #define WSIZE 8*sizeOf(int)
    long pcount_for(unsigned long x){
    	size_t i;
    	long result = 0;
    	for(i = 0; i < WSIZE; i++){
    		unsigned bit = (x >> i) & 0x1;
    		result += bit;
    	}
    	return result;
    }
    
    //into while loop..
    long pcount_while(unsigned long x){
    	size_t i;
    	long result = 0;
    	while(i < WSIZE){
    		unsigned bit = (x >> i) & 0x1;
    		result += bit;
    		i++;
    	}
    	return result;
    }

    for(init; test; update){
    	body
    }
    
    init
    while(test){
    	update
    	body
    }

switch 문은 점프테이블에 기록된 주소를 기반으로 동작

    switch_eg:
    	movq %rdx, %rcx
    	cmpq $6, %rdi           //rdi가 6보다 크면, 즉 입력이 switch 범위를 벗어난 default인 경우
    	ja L8                   //L8이 디폴트일거임
    	jmp *L4(, %rdi, 8)      //rdi입력 * 8 + L4가 가리키는 주소로 점프

7

프로시저 : 제어 시작부로갔다 리턴지점으로오기, 데이터 인자와 리턴값 레지스터에, 프로시저실행중 스택메모리관리, 리턴시 반환

스택 : 스택은 높은주소가 바닥이다. 위에서부터 아래로 내려가며 쌓인다. %rsp가 스택포인터로 stack메모리의 top을 가리키고있다.

pushq : %rsp를 8감소시킨다 → %rsp가 아래로내려간다 → 스택의 공간이 확보된다, %rsp가 가리키는곳에 기록한다 → 확보된 스택공간에 내용을 집어넣는다

popq : %rsp가 가리키는 값을 읽어온다, %rsp를 8 증가시킨다 → %rsp가 위로 올라간다 → 스택 공간일 비워준다.

callq : 프로시져 호출 리턴할 주소를 스택에 push, label로 점프

ret : 프로시져 리턴 call할 떄 스택에 push된 return주소를 pop해서 해당 주소로 탈출

ex) 400544가 400550을 호출 → 스택에 돌아올곳인 400549가 push됨 (sp인 %rsp가 감소, 해당 공간에 리턴주소인 40549가 기록됨) 400550이 호출되었으므로 %rip가 가리키는곳 400550으로 변경됨 (%rip는 다음 인스트럭션 주소) 호출된 400550실행 → 한줄한줄 실행될 때마다 %rip와 %rsp에 변경이 생기겠지만, 스택은 다시 리턴주소가 있는곳까지 pop될 것. 400550의 ret를 만남 (400557) → ret은 스택을 pop시켜 return주소를 rip에 받음. (sp인 %rsp가 다시 증가, 400549가 %rip에 기록됨) 따라서 ret이후에는 %rip가 가리키는 곳, 즉 다음 인스트럭션인 400549로 제어가 이동.

함수 호출 ⇒ 스택에 리턴되어야 할 주소를 기록, 제어가 프로시저로 옮겨감

함수 리턴 ⇒ 스택으로부터 리턴주소를 받아 rip에 기록, 제어가 해당 리턴주소로 옮겨감.

데이터흐름

인자 rdi, rsi, rdx, rcx, r8, r9 이렇게 6가지사용, 리턴값은 rax이용 정 부족하면 스택도 씀

스택체제 : 스택이 호출됐을 때 부터 리턴시 까지 ← 스택은 프레임으로 할당됨.

스택프레임 : 프레임포인터 %rbp, 스택포인터 %rsp

프로시져에 진입할 때에 프레임이 할당됨. call명령으로 알아서 스택에 push, return시에 알아서 pop

재귀적으로 호출된다거나 함수안에서 다른 함수가 불리어서 프로시져가 스택프레임을 더 할당받아야 할 필요가 있으면 계속 추가로 할당을 받음

지역변수도 주소를 사용하게되면 스택에 할당해야함. 레지스터에는 주소가 없다!!

    long call_incr(){
    	long v1 = 15213;
    	long v2 = incr(&v1, 3000);         //v1의 주소가 필요하므로 스택 사용해야함.
    	return v1 + v2;
    }
    
    long incr(long *p, long val){
    	long x = *p;
    	long y = x + val;
    	*p = y;
    	return x;
    }

    call_incr :
    	subq $16, %rsp;
    	movq $15213, 8($rsp);
    	movq $3000, $esi;
    	leaq 8($rsp), $rdi;      //rsp주소 + 8을 rdi에 저장 -> rdi에 15213의주소
    	callq incr
    	addq 8(%rsp), %rax
    	addq $16, $rsp
    	ret
    
    incr:
    	movq (%rdi), %rax        //괄호는 *와 같은 역할을 한다. 그 주소의 값을 가져오는거
    	addq %rax, %rsi
    	movq %rsi, (%rdi)        //여기서도 마찬가지. %rdi가 가리키는 곳의 값을 바꿈.
    	ret

인자로 사용하는 rdi rsi rdx rcx r8 r9는 다른함수의 호출로 인해 지워질 수 있음 따라서 호출자는 임시값들을 프레임에 저장해서 호출시에 보관해주고, callee도 임시 값들 사용전에 프레임에 보관, 리턴되면 복원. caller도 callee임.

!!관습 정리!! caller saved : %rax, %rdi, %rsi, %rdx, %rcx, %r8, %r9, %r10, %r11 callee saved : %rbx, %r12, %r13, %r14, %rbp, %rsp %rax : 반환 %rdi ~ %r9 : 인자 %r10, %r11 : 호출자-저장 임시 %r12 ~ %r14 : 피호출자-저장 임시 %rbp : 스택프레임(?) %rsp : 스텍포인터

8

메모리 참조 버그

배열의 범위를 벗어나도 바로 segmentation fault가 안 뜰 수 있다. 오류가 난다는건 중요한 부분을 찔렀다는 이야기임.

버퍼오버플로우 : 배열에 할당된 크기 이상의 메모리에 접근을 시도하는 것. 보안 취약성의 원인임.