본문으로 이동
  • 현재 모든 문서는 작성 중입니다. 보시는 데 불편함이 있더라도 양해 부탁드립니다.

System V ABI: 두 판 사이의 차이

~ldmsys
잔글편집 요약 없음
ABI 적용 범위·호출 규약 보강 및 스택 예시와 공식 참고 문헌 추가
 
1번째 줄: 1번째 줄:
'''System V ABI'''(System V Application Binary Interface)는 유닉스 계열 운영체제에서 실행 파일 형식, 데이터 타입 크기, 함수 호출 규약 등을 정의하는 규격이다.   
'''System V ABI'''(System V Application Binary Interface)는 유닉스 계열 운영체제에서 실행 파일 형식, 데이터 타입 크기, 함수 호출 규약 등을 정의하는 규격이다.   


현대의 64비트 UNIX 계열 (Linux, *BSD) 시스템에서는 주로 '''amd64(x86-64) System V ABI'''가 사용되기에 이 문서는 '''amd64(x86-64) System V ABI'''를 중심으로 설명한다.
서로 따로 컴파일한 함수가 함께 실행되려면 인자를 어디에 놓고, 결과를 어디서 받으며, 어떤 레지스터 값을 유지할지 약속해야 한다. 함수 선언이 같아도 한쪽은 인자를 레지스터에 넣고 다른 쪽은 스택에서 찾는다면 호출은 성립하지 않는다. ABI는 이렇게 바이너리 사이에서 맞춰야 할 약속을 정한다.
 
System V ABI에는 공통 규격과 아키텍처별 보충 규격인 '''psABI'''(Processor-Specific ABI)가 있다. 이 문서는 x86-64 Linux·BSD 등에서 사용하는 '''amd64(x86-64) System V ABI의 LP64 모델'''과 C 함수 호출을 중심으로 설명한다. 다른 아키텍처나 Windows x64의 호출 규약에는 아래 레지스터 순서를 그대로 적용할 수 없다.<ref name="psabi-intro">[https://gitlab.com/x86-psABIs/x86-64-ABI/-/blob/master/x86-64-ABI/introduction.tex AMD64 psABI, Introduction]. LP64·ILP32 모델과 규격의 적용 범위.</ref>


== amd64 System V ABI의 특징 ==
== amd64 System V ABI의 특징 ==
7번째 줄: 9번째 줄:
=== 데이터 모델 (LP64) ===
=== 데이터 모델 (LP64) ===


amd64 System V ABI에서는 다음과 같은 LP64 데이터 모델을 사용한다.
LP64 모델에서는 다음과 같은 데이터 타입 크기를 사용한다.


* <code>int</code> : 32비트
* <code>int</code> : 32비트
13번째 줄: 15번째 줄:
* 포인터(<code>void *</code> 등) : 64비트
* 포인터(<code>void *</code> 등) : 64비트


이는 C 코드에서 정수와 포인터 크기를 가정할 때 중요한 전제이다.
이는 C 코드에서 정수와 포인터 크기를 가정할 때 중요한 전제이다. 같은 x86-64 명령어를 쓰더라도 x32 ABI는 ILP32 모델을 사용하므로 구분해야 한다.<ref name="psabi-intro" />


=== 함수 인자 전달 규칙 ===
=== 함수 인자 전달 규칙 ===


정수형, 포인터형 등 대부분의 스칼라 인자는 다음 순서의 레지스터로 전달된다.
정수형과 포인터형 인자는 다음 순서의 범용 레지스터로 전달된다. 아래 순서는 64비트 레지스터 이름이며, <code>int</code>처럼 32비트인 값은 각각의 하위 32비트를 사용한다. 이때 남는 상위 비트의 값은 ABI가 보장하지 않는다.<ref name="psabi-call">[https://gitlab.com/x86-psABIs/x86-64-ABI/-/blob/master/x86-64-ABI/low-level-sys-info.tex AMD64 psABI, Low Level System Information]. Function Calling Sequence의 레지스터 보존, 스택 프레임, 인자 분류 및 반환 규칙.</ref>


{| class="wikitable"
{| class="wikitable"
35번째 줄: 37번째 줄:
|}
|}


* 7번째 인자부터는 스택에 8바이트 단위로 저장된 뒤 전달된다.
* <code>int</code>나 포인터만 나열한 경우 일곱 번째부터는 스택으로 전달된다. <code>int</code>의 크기는 4바이트지만 이 경우 스택 인자 슬롯은 8바이트 단위로 배치된다.
* 부동소수점 인자(<code>float</code>, <code>double</code>)는 XMM0–XMM7 레지스터를 통해 전달되며, 정수 인자와는 별도로 순서가 관리된다.
* 부동소수점 인자(<code>float</code>, <code>double</code>)는 XMM0–XMM7 레지스터를 통해 전달되며, 정수 인자와는 별도로 순서가 관리된다.


스택은 함수 호출 시 16바이트 정렬(alignment)을 유지해야 하며, 컴파일러가 이를 맞추도록 코드를 생성한다.
정수와 부동소수점 레지스터는 별도로 배정된다. 예를 들어 <code>f(int a, double b, int c, double d)</code>에서는 <code>a</code>와 <code>c</code>가 EDI·ESI에, <code>b</code>와 <code>d</code>가 XMM0·XMM1에 들어간다. 소스 코드의 몇 번째 인자인지만으로 레지스터를 고르면 안 된다.
 
구조체는 크기와 필드 배치에 따라 INTEGER·SSE·MEMORY 등의 클래스로 분류된다. 하나의 구조체가 여러 레지스터를 쓰거나, 정수·벡터 레지스터를 함께 쓰거나, 스택으로 전달될 수 있다. 따라서 “인자 여섯 개까지는 레지스터”는 정수·포인터만 사용하는 단순한 경우의 설명이다.<ref name="psabi-call" />
 
=== 스택 정렬과 red zone ===
 
일반적인 호출에서는 <code>call</code> 직전의 RSP가 16바이트 경계에 맞아야 한다. <code>call</code>이 8바이트 반환 주소를 스택에 넣으므로, 피호출 함수에 진입한 직후에는 <code>RSP + 8</code>이 16의 배수이다. 함수가 다시 다른 함수를 호출한다면 그 호출 직전의 정렬도 맞춰야 한다. 스택으로 전달하는 타입이 더 강한 정렬을 요구하면 그 조건도 따른다.<ref name="psabi-call" />
 
사용자 공간의 이 ABI는 현재 RSP 아래 128바이트를 '''red zone'''으로 둔다. 시그널 처리 과정에서도 이 영역을 보존하므로, 함수는 RSP를 움직이지 않고 임시 데이터를 둘 수 있다. 다만 다른 함수를 호출하면 그 함수의 스택과 겹칠 수 있으므로 호출을 넘어서 보관할 값에는 사용할 수 없다. 특히 다른 함수를 호출하지 않는 리프 함수(Leaf Function)에서 유용하다. Linux 커널 코드는 이 영역을 사용할 수 없다.<ref name="psabi-call" /><ref name="psabi-linux">[https://gitlab.com/x86-psABIs/x86-64-ABI/-/blob/master/x86-64-ABI/kernel.tex AMD64 psABI, Linux Conventions]. 사용자 함수 호출과 Linux 시스템 콜의 차이 및 커널의 red zone 제한.</ref>


=== 반환값 규칙 ===
=== 반환값 규칙 ===


* 대부분의 정수/포인터 반환값: RAX
* <code>int</code> 반환값: EAX, 즉 RAX의 하위 32비트
* 128비트까지의 일부 정수/구조체 반환: RAX와 RDX 조합
* <code>long</code>·포인터 반환값: RAX
* 부동소수점 반환값: XMM0
* <code>__int128</code> 또는 두 INTEGER 부분으로 분류된 구조체: RAX와 RDX
* <code>float</code>·<code>double</code> 반환값: XMM0
 
구조체 반환도 필드의 분류를 따른다. 예를 들어 <code>struct { double x; long y; }</code>는 XMM0와 RAX를 함께 사용한다. 크기만 보고 모든 작은 구조체가 RAX·RDX로 반환된다고 가정하면 안 된다.


더 큰 구조체 반환 등 특수한 경우에는 호출자가 반환 버퍼를 준비하고 포인터를 넘기는 방식 등이 사용된다.
MEMORY로 분류된 반환 타입은 호출자가 버퍼를 마련하고 그 주소를 숨은 첫 인자로 RDI에 전달한다. 이 때문에 원래 첫 번째 정수·포인터 인자는 RSI부터 배정된다. 함수는 버퍼에 결과를 쓰고, 반환 시 RAX에도 그 버퍼 주소를 넣는다.<ref name="psabi-call" />


=== 레지스터 보존 규약 ===
=== 레지스터 보존 규약 ===
53번째 줄: 66번째 줄:


* 호출자 저장(caller-saved): 함수 호출 시 덮어써져도 되므로, 필요한 경우 '''호출하는 쪽'''이 미리 저장해야 하는 레지스터   
* 호출자 저장(caller-saved): 함수 호출 시 덮어써져도 되므로, 필요한 경우 '''호출하는 쪽'''이 미리 저장해야 하는 레지스터   
* 피호출자 저장(callee-saved): 함수가 종료될 때 원래 값이 유지되어야 하므로, '''호출되는 함수'''가 저장·복원해야 하는 레지스터
* 피호출자 저장(callee-saved): 함수가 종료될 때 원래 값이 유지되어야 하므로, '''호출되는 함수'''가 값을 바꾼다면 저장·복원해야 하는 레지스터


대표적인 규약은 다음과 같다.
대표적인 규약은 다음과 같다.
65번째 줄: 78번째 줄:
|}
|}


RSP(스택 포인터)는 호출 전후에 일관되게 유지되어야 한다.
RSP(스택 포인터)도 호출자에게 돌아왔을 때 올바르게 복원되어야 한다. RBP는 보존 대상이지만 반드시 프레임 포인터로 써야 하는 것은 아니다. 컴파일러는 RSP 기준으로 지역 변수에 접근하고 RBP를 다른 용도로 사용할 수도 있다.<ref name="psabi-call" />
 
호출자 저장이라는 말은 호출할 때마다 모든 레지스터를 저장하라는 뜻이 아니다. 예를 들어 RAX의 값이 다음 함수 호출 뒤에도 필요하다면 호출자가 다른 곳에 보관해야 한다. 반대로 그 값이 더 이상 필요 없다면 저장할 이유가 없다.


== C 언어 예시 ==
== C 언어 예시 ==
81번째 줄: 96번째 줄:
위 호출에서 <code>foo</code>는 amd64 System V ABI에 따라 다음과 같이 인자를 받는다.
위 호출에서 <code>foo</code>는 amd64 System V ABI에 따라 다음과 같이 인자를 받는다.


* <code>a</code> → RDI (1번째 인자)
* <code>a</code> → EDI (1번째 인자)
* <code>b</code> → RSI (2번째 인자)
* <code>b</code> → ESI (2번째 인자)
* <code>c</code> → RDX (3번째 인자)
* <code>c</code> → EDX (3번째 인자)
* <code>d</code> → RCX (4번째 인자)
* <code>d</code> → ECX (4번째 인자)
* <code>e</code> → R8  (5번째 인자)
* <code>e</code> → R8D (5번째 인자)
* <code>f</code> → R9  (6번째 인자)
* <code>f</code> → R9D (6번째 인자)
* <code>g</code> → 스택 상의 슬롯 (7번째 인자)
* <code>g</code> → 스택 상의 슬롯 (7번째 인자)


<code>foo</code>가 <code>int</code>를 반환하면, 그 값은 RAX에 담겨 <code>caller</code>로 전달된다.
<code>foo</code>가 <code>int</code>를 반환하면, 그 값은 EAX에 담겨 <code>caller</code>로 전달된다.
 
아래는 GCC 14.2에서 <code>-O2 -fno-optimize-sibling-calls -S -masm=intel</code>로 얻은 <code>caller</code>의 호출 부분이다. 컴파일러 지시문을 제외했으며, 명령의 배치나 스택 공간을 확보하는 방식은 컴파일러와 옵션에 따라 달라질 수 있다.
 
<pre>
caller:
    sub  rsp, 16
    mov  r9d, 6
    mov  r8d, 5
    mov  ecx, 4
    push 7
    mov  edx, 3
    mov  esi, 2
    mov  edi, 1
    call foo@PLT
    add  rsp, 24
    ret
</pre>
 
<code>caller</code> 진입 시 RSP는 16으로 나눈 나머지가 8이다. <code>sub</code>로 16바이트를 확보하고 <code>push</code>로 8바이트를 더 사용하면, <code>call</code> 직전에는 16바이트 정렬이 맞는다. 이어서 반환 주소가 들어간다.
 
<pre>
foo 진입 직후, 높은 주소
      +-----------------------+
RSP+16 | caller가 확보한 공간  |
      +-----------------------+
RSP+8  | 7번째 인자 g = 7      |  8바이트 슬롯
      +-----------------------+
RSP    | caller로 돌아갈 주소  |  call이 저장
      +-----------------------+
      낮은 주소
</pre>
 
따라서 <code>foo</code>는 진입 직후 <code>[RSP + 8]</code>의 하위 4바이트에서 <code>g</code>를 읽을 수 있다. 함수가 RSP를 바꾸면 그에 맞춰 오프셋도 달라진다. 반환 뒤 <code>caller</code>는 자신이 사용한 24바이트를 해제하고, EAX에 담긴 결과를 그대로 반환한다.


부동소수점 인자의 경우:
부동소수점 인자의 경우:
104번째 줄: 152번째 줄:
* <code>y</code> → XMM1   
* <code>y</code> → XMM1   
* 반환값(<code>double</code>) → XMM0
* 반환값(<code>double</code>) → XMM0
== 가변 인자와 시스템 콜 ==
<code>printf</code>처럼 가변 인자 함수에 호출할 때에는 AL(RAX의 하위 8비트)에 인자 전달용 벡터 레지스터 사용 개수의 상한을 넣는다. 값의 범위는 0부터 8까지이다. 예를 들어 <code>printf("%f", 1.0)</code>에서는 형식 문자열 포인터가 RDI, <code>double</code> 값이 XMM0에 들어가며 AL에는 1을 줄 수 있다. 컴파일러가 생성하는 호출에는 이 처리도 포함된다.<ref name="psabi-call" />
앞의 규칙은 사용자 공간 '''함수 호출'''의 규칙이다. x86-64 Linux의 <code>syscall</code> 명령은 인자를 RDI·RSI·RDX·R10·R8·R9로 전달하며, 네 번째 인자에 RCX 대신 R10을 사용한다. RAX에는 시스템 콜 번호를 넣고 결과도 RAX로 받는다. <code>syscall</code>이 RCX와 R11을 변경한다는 점도 일반 함수 호출과 구분해야 한다. C 라이브러리의 <code>read()</code>를 호출하면, 라이브러리 함수가 이 두 규약 사이를 연결한다.<ref name="psabi-linux" />
== 참고 문헌 ==
<references />

2026년 11월 1일 (일) 03:39 기준 최신판

System V ABI(System V Application Binary Interface)는 유닉스 계열 운영체제에서 실행 파일 형식, 데이터 타입 크기, 함수 호출 규약 등을 정의하는 규격이다.

서로 따로 컴파일한 함수가 함께 실행되려면 인자를 어디에 놓고, 결과를 어디서 받으며, 어떤 레지스터 값을 유지할지 약속해야 한다. 함수 선언이 같아도 한쪽은 인자를 레지스터에 넣고 다른 쪽은 스택에서 찾는다면 호출은 성립하지 않는다. ABI는 이렇게 바이너리 사이에서 맞춰야 할 약속을 정한다.

System V ABI에는 공통 규격과 아키텍처별 보충 규격인 psABI(Processor-Specific ABI)가 있다. 이 문서는 x86-64 Linux·BSD 등에서 사용하는 amd64(x86-64) System V ABI의 LP64 모델과 C 함수 호출을 중심으로 설명한다. 다른 아키텍처나 Windows x64의 호출 규약에는 아래 레지스터 순서를 그대로 적용할 수 없다.[1]

amd64 System V ABI의 특징

데이터 모델 (LP64)

LP64 모델에서는 다음과 같은 데이터 타입 크기를 사용한다.

  • int : 32비트
  • long, long long : 64비트
  • 포인터(void * 등) : 64비트

이는 C 코드에서 정수와 포인터 크기를 가정할 때 중요한 전제이다. 같은 x86-64 명령어를 쓰더라도 x32 ABI는 ILP32 모델을 사용하므로 구분해야 한다.[1]

함수 인자 전달 규칙

정수형과 포인터형 인자는 다음 순서의 범용 레지스터로 전달된다. 아래 순서는 64비트 레지스터 이름이며, int처럼 32비트인 값은 각각의 하위 32비트를 사용한다. 이때 남는 상위 비트의 값은 ABI가 보장하지 않는다.[2]

인자 번호 사용 레지스터
1번째 인자 RDI
2번째 인자 RSI
3번째 인자 RDX
4번째 인자 RCX
5번째 인자 R8
6번째 인자 R9
  • int나 포인터만 나열한 경우 일곱 번째부터는 스택으로 전달된다. int의 크기는 4바이트지만 이 경우 스택 인자 슬롯은 8바이트 단위로 배치된다.
  • 부동소수점 인자(float, double)는 XMM0–XMM7 레지스터를 통해 전달되며, 정수 인자와는 별도로 순서가 관리된다.

정수와 부동소수점 레지스터는 별도로 배정된다. 예를 들어 f(int a, double b, int c, double d)에서는 a와 c가 EDI·ESI에, b와 d가 XMM0·XMM1에 들어간다. 소스 코드의 몇 번째 인자인지만으로 레지스터를 고르면 안 된다.

구조체는 크기와 필드 배치에 따라 INTEGER·SSE·MEMORY 등의 클래스로 분류된다. 하나의 구조체가 여러 레지스터를 쓰거나, 정수·벡터 레지스터를 함께 쓰거나, 스택으로 전달될 수 있다. 따라서 “인자 여섯 개까지는 레지스터”는 정수·포인터만 사용하는 단순한 경우의 설명이다.[2]

스택 정렬과 red zone

일반적인 호출에서는 call 직전의 RSP가 16바이트 경계에 맞아야 한다. call이 8바이트 반환 주소를 스택에 넣으므로, 피호출 함수에 진입한 직후에는 RSP + 8이 16의 배수이다. 함수가 다시 다른 함수를 호출한다면 그 호출 직전의 정렬도 맞춰야 한다. 스택으로 전달하는 타입이 더 강한 정렬을 요구하면 그 조건도 따른다.[2]

사용자 공간의 이 ABI는 현재 RSP 아래 128바이트를 red zone으로 둔다. 시그널 처리 과정에서도 이 영역을 보존하므로, 함수는 RSP를 움직이지 않고 임시 데이터를 둘 수 있다. 다만 다른 함수를 호출하면 그 함수의 스택과 겹칠 수 있으므로 호출을 넘어서 보관할 값에는 사용할 수 없다. 특히 다른 함수를 호출하지 않는 리프 함수(Leaf Function)에서 유용하다. Linux 커널 코드는 이 영역을 사용할 수 없다.[2][3]

반환값 규칙

  • int 반환값: EAX, 즉 RAX의 하위 32비트
  • long·포인터 반환값: RAX
  • __int128 또는 두 INTEGER 부분으로 분류된 구조체: RAX와 RDX
  • float·double 반환값: XMM0

구조체 반환도 필드의 분류를 따른다. 예를 들어 struct { double x; long y; }는 XMM0와 RAX를 함께 사용한다. 크기만 보고 모든 작은 구조체가 RAX·RDX로 반환된다고 가정하면 안 된다.

MEMORY로 분류된 반환 타입은 호출자가 버퍼를 마련하고 그 주소를 숨은 첫 인자로 RDI에 전달한다. 이 때문에 원래 첫 번째 정수·포인터 인자는 RSI부터 배정된다. 함수는 버퍼에 결과를 쓰고, 반환 시 RAX에도 그 버퍼 주소를 넣는다.[2]

레지스터 보존 규약

amd64 System V ABI는 어떤 레지스터를 누가 보존해야 하는지도 정의한다.

  • 호출자 저장(caller-saved): 함수 호출 시 덮어써져도 되므로, 필요한 경우 호출하는 쪽이 미리 저장해야 하는 레지스터
  • 피호출자 저장(callee-saved): 함수가 종료될 때 원래 값이 유지되어야 하므로, 호출되는 함수가 값을 바꾼다면 저장·복원해야 하는 레지스터

대표적인 규약은 다음과 같다.

구분 레지스터
호출자 저장 RAX, RCX, RDX, RSI, RDI, R8, R9, R10, R11, XMM0–XMM15
피호출자 저장 RBX, RBP, R12, R13, R14, R15

RSP(스택 포인터)도 호출자에게 돌아왔을 때 올바르게 복원되어야 한다. RBP는 보존 대상이지만 반드시 프레임 포인터로 써야 하는 것은 아니다. 컴파일러는 RSP 기준으로 지역 변수에 접근하고 RBP를 다른 용도로 사용할 수도 있다.[2]

호출자 저장이라는 말은 호출할 때마다 모든 레지스터를 저장하라는 뜻이 아니다. 예를 들어 RAX의 값이 다음 함수 호출 뒤에도 필요하다면 호출자가 다른 곳에 보관해야 한다. 반대로 그 값이 더 이상 필요 없다면 저장할 이유가 없다.

C 언어 예시

다음 예시는 정수 인자가 어떻게 레지스터와 스택으로 전달되는지 보여준다.

int foo(int a, int b, int c, int d, int e, int f, int g);

int caller(void) {
    return foo(1, 2, 3, 4, 5, 6, 7);
}

위 호출에서 foo는 amd64 System V ABI에 따라 다음과 같이 인자를 받는다.

  • a → EDI (1번째 인자)
  • b → ESI (2번째 인자)
  • c → EDX (3번째 인자)
  • d → ECX (4번째 인자)
  • e → R8D (5번째 인자)
  • f → R9D (6번째 인자)
  • g → 스택 상의 슬롯 (7번째 인자)

foo가 int를 반환하면, 그 값은 EAX에 담겨 caller로 전달된다.

아래는 GCC 14.2에서 -O2 -fno-optimize-sibling-calls -S -masm=intel로 얻은 caller의 호출 부분이다. 컴파일러 지시문을 제외했으며, 명령의 배치나 스택 공간을 확보하는 방식은 컴파일러와 옵션에 따라 달라질 수 있다.

caller:
    sub  rsp, 16
    mov  r9d, 6
    mov  r8d, 5
    mov  ecx, 4
    push 7
    mov  edx, 3
    mov  esi, 2
    mov  edi, 1
    call foo@PLT
    add  rsp, 24
    ret

caller 진입 시 RSP는 16으로 나눈 나머지가 8이다. sub로 16바이트를 확보하고 push로 8바이트를 더 사용하면, call 직전에는 16바이트 정렬이 맞는다. 이어서 반환 주소가 들어간다.

foo 진입 직후, 높은 주소
       +-----------------------+
RSP+16 | caller가 확보한 공간   |
       +-----------------------+
RSP+8  | 7번째 인자 g = 7       |  8바이트 슬롯
       +-----------------------+
RSP    | caller로 돌아갈 주소   |  call이 저장
       +-----------------------+
       낮은 주소

따라서 foo는 진입 직후 [RSP + 8]의 하위 4바이트에서 g를 읽을 수 있다. 함수가 RSP를 바꾸면 그에 맞춰 오프셋도 달라진다. 반환 뒤 caller는 자신이 사용한 24바이트를 해제하고, EAX에 담긴 결과를 그대로 반환한다.

부동소수점 인자의 경우:

double add_double(double x, double y);

double caller2(void) {
    return add_double(1.0, 2.0);
}
  • x → XMM0
  • y → XMM1
  • 반환값(double) → XMM0

가변 인자와 시스템 콜

printf처럼 가변 인자 함수에 호출할 때에는 AL(RAX의 하위 8비트)에 인자 전달용 벡터 레지스터 사용 개수의 상한을 넣는다. 값의 범위는 0부터 8까지이다. 예를 들어 printf("%f", 1.0)에서는 형식 문자열 포인터가 RDI, double 값이 XMM0에 들어가며 AL에는 1을 줄 수 있다. 컴파일러가 생성하는 호출에는 이 처리도 포함된다.[2]

앞의 규칙은 사용자 공간 함수 호출의 규칙이다. x86-64 Linux의 syscall 명령은 인자를 RDI·RSI·RDX·R10·R8·R9로 전달하며, 네 번째 인자에 RCX 대신 R10을 사용한다. RAX에는 시스템 콜 번호를 넣고 결과도 RAX로 받는다. syscall이 RCX와 R11을 변경한다는 점도 일반 함수 호출과 구분해야 한다. C 라이브러리의 read()를 호출하면, 라이브러리 함수가 이 두 규약 사이를 연결한다.[3]

참고 문헌

  1. ↑ 1.0 1.1 AMD64 psABI, Introduction. LP64·ILP32 모델과 규격의 적용 범위.
  2. ↑ 2.0 2.1 2.2 2.3 2.4 2.5 2.6 AMD64 psABI, Low Level System Information. Function Calling Sequence의 레지스터 보존, 스택 프레임, 인자 분류 및 반환 규칙.
  3. ↑ 3.0 3.1 AMD64 psABI, Linux Conventions. 사용자 함수 호출과 Linux 시스템 콜의 차이 및 커널의 red zone 제한.