잠시만요, 달이 떠오르면 글도 환해질 거예요.
int add(int a, int b) {
return a + b;
}
int main(void) {
return add(10, 20);
}#include <stdio.h>
#define MAX_SIZE 100
int main(void) {
int size = MAX_SIZE;
return 0;
}#define MAX_SIZE 100
int size = MAX_SIZE;int size = 100;int result = a + b;a + ba + ;result = a + b;int a = 10;
int b = "hello";int add(int a, int b) {
return a + b;
}int calculate(void) {
int a = 10;
int b = 20;
return a + b;
}int add(int a, int b) {
return a + b;
}int add(int a, int b);
int main(void) {
return add(10, 20);
}int add(int a, int b) {
return a + b;
}execve("/path/to/program", argv, envp);
컴파일러, 어셈블러, 머신 코드로의 변환 과정
앞선 글에서는 명령어 집합 구조(ISA)를 소개하며, ISA가 소프트웨어와 프로세서 사이의 기계 수준 계약을 정의한다는 점을 살펴보았습니다.
하지만 우리가日常적으로 작성하는 것은 C, Java, Go 같은 고수준 언어이고, CPU가 실행하는 것은 기계 명령어입니다. 둘 사이에는 뚜렷한 표현 수준의 차이가 존재합니다.
그렇다면 소스 코드는 과연 어떤 과정을 거쳐 기계 명령어가 되는 걸까요?
많은 사람은 이 과정을 다음과 같이 단순하게 이해합니다:
잘못된 말은 아니지만, 이 설명은 그 사이에 숨어 있는 수많은 중요한 단계를 가려 버립니다. 컴파일러는 소스 코드의 문법과 의미를 이해하는 데 그치지 않고, 프로그램을 목표 아키텍처에 적합한 명령어로 변환해야 합니다. 어셈블러는 명령어 표현을 머신 코드로 인코딩하고, 링커는 서로 다른 오브젝트 파일 사이의 참조를 처리하며, 운영체제는 최종 프로그램을 메모리에 적재해야 합니다.
이 글에서는 C 언어와 일반적인 Linux ELF 툴체인을 예로 들어, 소스 코드에서 CPU 실행까지의 전체 과정을 연결해 보겠습니다.
1. 소스 코드는 CPU가 실행하는 대상이 아니다
먼저 간단한 C 프로그램을 살펴보겠습니다:
사람은 이 코드를 바로 이해할 수 있습니다. 덧셈 함수를 정의한 다음main에서 호출합니다.
하지만 CPU는 이를 직접 이해할 수 없습니다:
이러한 의미는 반드시 컴파일러가 먼저 처리해야 합니다.
컴파일러의 임무는 각 키워드를 단순히 기계 명령어 한 줄로 치환하는 것이 아니라, 고수준 언어로 기술된 프로그램의 논리를 목표 머신이 실행할 수 있는 형태로 단계적으로 변환하는 것입니다.
대표적인 컴파일 및 실행 흐름은 다음과 같습니다:
이는 이해하기 쉽게 그려 낸 전형적인 툴체인 모델입니다. 실제 컴파일러는 어셈블리 텍스트를 출력한 뒤 독립 어셈블러를 호출하지 않고 곧바로 오브젝트 파일을 생성할 수도 있으며, 언어와 툴체인에 따라 실제 절차는 달라집니다.
2. 컴파일러 프런트엔드: 프로그램이 표현하는 의미를 이해하기
컴파일러가 먼저 해결해야 할 문제는 기계 코드를 생성하는 것이 아니라 소스 코드를 이해하는 것입니다.
이 부분을 보통 컴파일러 프런트엔드(Frontend)라고 부릅니다. 소스 코드를 분석하고, 컴파일러 내부에서 처리할 수 있는 구조로 변환하는 일을 담당합니다.
2.1 전처리: 소스 코드의 전처리 지시문 펼치기
C 언어의 경우 컴파일 과정은 보통 전처리로 시작합니다.
전처리기는#으로 시작하는 전처리 지시문을 처리합니다. 예를 들면 다음과 같습니다:
전처리기는 헤더 파일을 전개하고, 매크로를 치환하며, 조건부 컴파일 지시문에 따라 어떤 코드가 이후 컴파일에 참여할지 결정합니다.
예를 들어:
매크로 치환을 거치면 다음과 같이 됩니다:
전처리가 끝나면 컴파일러는 전개된 소스 코드 텍스트를 얻습니다.
주의할 점은 전처리가 모든 언어에 존재하는 단계는 아니라는 것입니다. 여기서 다루는 것은 C/C++처럼 전처리 메커니즘을 갖춘 언어입니다.
2.2 어휘 분석: 코드의 기본 단위 식별하기
다음은 어휘 분석(Lexical Analysis)입니다.
컴파일러는 연속된 문자들을 의미 있는 어휘 단위, 즉 토큰(Token)으로 하나씩 분리해야 합니다.
예를 들어:
어휘 분석기는 다음과 같이 식별합니다:
소스 코드 조각
토큰 종류
`int`
키워드
`result`
식별자
`=`
연산자
`a`
식별자
`+`
연산자
`b`
식별자
`;`
구분자
어휘 분석은 문자들이 어떻게 기본 언어 요소를 구성하는지를 다루는 단계입니다.
이 단계는a와b가 실제로 존재하는지, 이 둘을 더할 수 있는지를 판단하는 역할을 하지 않습니다.
2.3 구문 분석: 코드의 구조 식별하기
어휘 분석으로 토큰을 얻은 뒤, 구문 분석기(Parser)는 언어의 문법 규칙에 따라 이 토큰들이 올바른 프로그램 구조를 구성할 수 있는지 판단합니다.
예를 들어:
는 하나의 덧셈 표현식으로 인식됩니다.
반면
는 일반적인 표현식 문법에 맞지 않아 구문 오류를 낳습니다.
구문 분석의 결과는 보통 추상 구문 트리(AST, Abstract Syntax Tree)로 구체화됩니다.
예를 들어 다음 표현식은
다음과 같이 추상화됩니다:
AST는 프로그램의 구조적 관계를 보존하지만, 의미 분석에 영향을 주지 않는 많은 표면적细节, 예를 들어 일부 괄호와 구분자는 생략합니다.
2.4 의미 분석: 프로그램이 타당한지 판단하기
문법이 올바르다고 해서 프로그램이 반드시 정상이라는 것은 아닙니다.
예를 들어:
문법 구조만 보면 이 코드는 정상적으로 파싱될 수 있지만, 타입이 서로 맞지 않아 의미론적으로 문제가 있습니다.
의미 분석(Semantic Analysis)에서는 다음을 검사합니다:
이러한 분석을 거친 뒤에야 컴파일러는 프로그램의 의미에 대한 완전한 이해를 조금씩 구축해 나갑니다.
3. 중간 표현 IR: 컴파일러를 구체적인 소스 언어에서 해방시키기
컴파일러가 각 고수준 언어를 각 CPU 아키텍처의 머신 코드로 직접 번역한다면, 조합의 수가 매우庞大해집니다.
소스 언어가 5종, 목표 아키텍처가 4종이라고 가정해 봅시다. 각 언어가 모든 목표 아키텍처에 대한 코드 생성을 독립적으로 구현한다면, 변환 경로를 20개나 유지해야 할 수 있습니다.
더 중요한 것은 서로 다른 언어에서도 다수의 기본 연산과 제어 흐름이 유사한 저수준 표현 방식을 공유한다는 점입니다.
이 문제를 해결하기 위해 현대적인 컴파일러는 대체로 중간 표현(Intermediate Representation, IR)을 도입합니다.
3.1 IR이란?
IR은 컴파일러 내부에서 사용되는 일종의 프로그램 표현 형식입니다.
C 언어처럼 개발자를 향한 표현력을 강조하지도 않고, 머신 코드처럼 특정 프로세서의 명령어 인코딩에 묶이지도 않습니다.
그 목표는 다음과 같습니다: 프로그램의 계산과 제어 흐름을 비교적 통일된 형태로 표현해, 컴파일러가 분석과 최적화를 수행하기 쉽게 만드는 것입니다.
예를 들어:
는 다음과 같은 LLVM IR로 변환될 수 있습니다:
여기서i32는 32비트 정수를 나타내고,add는 정수 덧셈을 나타내며,ret는 결과 반환을 나타냅니다.
이 IR은 이미 원래의 C 코드가 아니지만, 그렇다고 x86-64나 ARM64의 머신 코드도 아닙니다.
특정 CPU 아키텍처에 비교적 독립적인 계산 의미를 표현합니다.
3.2 IR이 필요한 이유
IR의 가장 중요한 가치는 프런트엔드와 백엔드의 분리입니다.
프런트엔드는 소스 언어를 IR로 변환하는 일만, 백엔드는 IR을 목표 아키텍처의 기계 명령어로 변환하는 일만 담당하면 됩니다.
이렇게 하면 소스 언어와 CPU 아키텍처 조합마다 완전한 컴파일러를 따로 구현할 필요가 없어집니다.
게다가 IR은 최적화를 위한 알맞은 작업 공간도 제공합니다.
예를 들어:
컴파일러는a와b가 모두 컴파일 시점에 알려진 상수라는 점을 찾아내어, 계산을 미리 끝내고 결과만 반환할 수 있습니다. 이러한 최적화를 상수 접기(Constant Folding)라고 합니다.
IR을 사용하면 공통 부분식 제거, 죽은 코드 삭제, 루프 최적화, 인라인 같은 컴파일 최적화도 쉽게 수행할 수 있습니다.
3.3 IR은 반드시 한 가지 형태만 있는 것은 아니다
IR은 정해진 하나의 포맷이 아닙니다.
서로 다른 컴파일러가 서로 다른 중간 표현을 사용할 수 있습니다. 예를 들면:
따라서 모든 중간 코드를 그저 동일한 IR로 동일시해서는 안 됩니다. 이들이 놓인 계층, 설계 목표, 실행 방식은 서로 다를 수 있습니다.
4. 컴파일러 백엔드: 목표 ISA를 향한 명령어 생성
프런트엔드 분석과 중간 표현 최적화를 마친 뒤, 컴파일러는 프로그램을 구체적인 목표 아키텍처가 실행할 수 있는 명령어로 변환해야 합니다.
이 부분을 보통 컴파일러 백엔드(Backend)라고 부릅니다.
백엔드는 목표 ISA의 구체적인 규칙을 알고 있어야 합니다. 예를 들면:
4.1 같은 로직, 다른 아키텍처의 명령어
여전히 덧셈 함수를 예로 들어 보면:
x86-64 아키텍처에서는 다음과 같이 생성될 수 있습니다:
AArch64 아키텍처에서는 다음과 같이 생성될 수 있습니다:
둘은 같은 계산 로직을 나타내지만 명령어의 형태가 다릅니다.
x86-64 예제의 인자 레지스터는 System V AMD64 ABI를 따르고, AArch64 예제는 일반적인 AArch64 프로시저 호출 규약의w0와w1으로 인자를 전달하고, 반환값은w0에 놓습니다.
이것은 중요한 차이점을 하나 보여 줍니다:
ISA는 명령어가 무엇을 할 수 있는지를 규정하고, ABI는 서로 다른 소프트웨어 모듈이 어떻게 협업하는지를 규정합니다.
ABI에는 보통 데이터 레이아웃, 함수 호출 규약, 오브젝트 파일 형식, 시스템 호출 인터페이스 같은 내용도 포함됩니다.
4.2 백엔드에서 추가로 처리할 레지스터 할당
IR에는 임시 변수가 아주 많이 존재할 수 있지만, 실제 프로세서의 범용 레지스터 수는 제한적입니다.
예를 들어 IR에는 다음과 같은 것들이 나타날 수 있습니다:
컴파일러는 이 임시 값들을 각각 어떤 물리 레지스터에 넣을지, 혹은 레지스터가 부족할 경우 스택 메모리에 임시로 저장할지를 결정해야 합니다.
이 과정을 레지스터 할당(Register Allocation)이라고 합니다.
레지스터 할당은 생성된 코드의 품질에 직접적인 영향을 줍니다. 레지스터를 효율적으로 쓰지 않으면 메모리 접근과 명령어 수가 늘어날 수 있어 성능에도 영향을 줍니다.
백엔드는 명령어 선택, 명령어 스케줄링, 주소 지정 방식 선택 같은 작업도 수행해야 하며, 최종적으로 목표 아키텍처가 요구하는 코드를 만들어 냅니다.
5. 어셈블러: 명령어 표현을 머신 코드로 인코딩하기
컴파일러 백엔드가 만들어 낸 명령어는 우선 어셈블리 언어로 표현할 수 있습니다.
어셈블리 언어는 기계 명령어에 가까운 텍스트 형태여서 사람이 읽고 디버깅하기 편리합니다.
예를 들어:
이 코드는 다음을 뜻합니다:
하지만 CPU는 이 텍스트를 직접 실행할 수는 없습니다.
어셈블러(Assembler)는 목표 ISA가 정한 명령어 인코딩 규칙에 따라 어셈블리 명령어를 머신 코드로 변환해야 합니다.
5.1 어셈블리 명령어는 어떻게 바이트가 되는가
앞의 x86-64 명령어를 예로 들면:
이에 대응하는 머신 코드 인코딩은 다음과 같습니다:
각각 나누어 보면:
어셈블리 명령어
머신 코드
의미
`mov eax, 10`
`B8 0A 00 00 00`
즉시값 10을 EAX에 기록
`add eax, 20`
`83 C0 14`
즉시값 20을 EAX에 더함
`ret`
`C3`
반환
여기서 나온 16진수 바이트가 최종적으로 오브젝트 파일에 기록되는 명령어 인코딩입니다.
주의할 점은 x86 명령어의 인코딩 형식이 고정 길이가 아니라는 것입니다. 명령어마다 들어가는 오피코드, 접두사, 주소 지정 정보, 즉시수의 개수가 달라질 수 있습니다.
반면 ARM64의 명령어 인코딩은 보통 고정 폭 32비트 형식을 따릅니다. ISA마다 인코딩 규칙의 차이가 크기 때문에, 서로 다른 아키텍처의 머신 코드가 대체로 직접 호환되지 않는 이유 중 하나이기도 합니다.
5.2 어셈블러는 단순 치환에 그치지 않는다
어셈블러는 이보다 더 복잡한 작업들도 함께 처리해야 합니다:
예를 들어:
어셈블러는 점프 명령어에서target까지의 거리를 계산하고, 명령어 인코딩 형식에 맞춰 알맞은 오프셋을 채워 넣어야 합니다.
아직 대상 주소를 확정할 수 없다면 재배치 레코드를 만들어 이후 링크 단계에서 처리하도록 남겨 둘 수 있습니다.
6. 오브젝트 파일: 머신 코드만으로는 아직 완전한 프로그램이 아니다
어셈블러가 만들어 내는 것은 보통 바로 실행할 수 있는 완전한 프로그램이 아니라 오브젝트 파일(Object File)입니다.
Linux 시스템에서 흔히 쓰이는 오브젝트 파일 형식은 ELF(Executable and Linkable Format)입니다.
예를 들어:
여기서 -c는 컴파일과 어셈블만 수행하고 최종 링크는 하지 않는다는 뜻입니다.
이렇게 만들어진 main.o에는 머신 코드가 들어 있으며, 심볼 테이블, 재배치 정보, 디버깅 정보 같은 메타데이터도 함께 담길 수 있습니다.
6.1 오브젝트 파일에는 무엇이 들어 있는가
ELF 오브젝트 파일은 보통 여러 개의 섹션(Section)으로 구성됩니다.
섹션 이름
용도
`.text`
프로그램 명령어를 저장
`.data`
초기화된 쓰기 가능한 전역 또는 정적 데이터를 저장
`.bss`
초기화되지 않았거나 0으로 초기화되는 데이터를 위한 공간 정보를 저장
`.rodata`
문자열 상수 같은 읽기 전용 데이터를 저장
`.symtab`
심볼 테이블. 함수, 변수 등의 심볼 정보를 기록
`.rela.text`
코드 섹션과 관련된 재배치 정보. 구체적인 형식은 아키텍처와 파일 종류에 따라 달라집니다.
이 중에서.bss는 보통SHT_NOBITS타입이라, 파일 안에 0으로 채운 데이터를 통째로 저장하지 않고 로드할 때 해당 메모리를 할당해 초기화합니다.
다음 명령으로 오브젝트 파일 정보를 확인할 수 있습니다:
6.2 오브젝트 파일에 심볼 테이블이 필요한 이유
소스 파일이 두 개 있다고 가정해 보겠습니다.
main.c:
add.c:
컴파일하고 나면 두 개의 오브젝트 파일이 만들어집니다:
를 컴파일할 때main.c컴파일러는 add라는 이름의 함수가 존재한다는 것은 알지만, 이 함수가 최종적으로 메모리의 어느 주소에 놓일지는 알지 못합니다.
따라서 오브젝트 파일에는add에 대한 심볼 참조가 남게 됩니다.
이렇게 심볼 테이블과 재배치 정보가 쓰이는 곳을 볼 수 있습니다.
7. 링커: 여러 오브젝트 파일을 하나로 묶기
링커(Linker)는 여러 오브젝트 파일과 필요한 라이브러리를 하나로 묶어 최종 프로그램을 만듭니다.
링커가 해결해야 할 핵심 문제는 두 가지입니다:
7.1 심볼 해석
앞의 예제에서 main.o가 add를 참조하고, add.o는 add.
링커는 이 심볼의 정의를 찾아서 둘 사이의 관계를 설정해야 합니다.
어떤 심볼의 정의를 찾지 못하면 다음과 같은 문제가 발생할 수 있습니다:
같은 심볼에 규칙에 맞지 않는 정의가 여러 개 존재하는 경우에도 중복 정의 오류가 발생할 수 있습니다.
7.2 재배치
심볼을 찾은 뒤에는 그것이 최종적으로 어떤 위치에 놓이는지도 결정해야 합니다.
예를 들어,main.o에는 add를 호출하는 명령어가 있지만, 단독으로 컴파일할 때는 add의 최종 주소가 아직 확정되지 않았습니다.
링커가 목표 파일들을 최종 프로그램의 주소 공간에 배치하면, 심볼 주소에 따라 호출 위치나 관련 주소 필드를 수정할 수 있습니다.
이 과정을 재배치(Relocation)라고 합니다.
재배치가 모든 주소를 링크 시점에 확정해야 한다는 뜻은 아닙니다. 동적 링크 방식의 프로그램에서는 일부 심볼과 주소가 프로그램 로드 시점에 동적 링커에 의해 계속 처리될 수 있습니다.
7.3 정적 링크와 동적 링크
링크할 때 프로그램이 의존하는 라이브러리는 서로 다른 방식으로 구성할 수 있습니다.
정적 링크는 필요한 라이브러리 코드의 관련 부분을 최종 실행 파일에 복사합니다. 프로그램을 배포할 때에는 보통 해당 동적 라이브러리 파일에 더 이상 의존하지 않지만, 실행 파일이 더 커질 수 있고 라이브러리가 업데이트될 때에도 보통 다시 링크해야 합니다.
동적 링크는 프로그램이 실행 시점에 공유 라이브러리에 의존하도록 만듭니다. 실행 파일에는 동적 라이브러리와 그 심볼에 대한 참조가 남고, 로드 시점에 동적 링커가 필요한 매핑과 심볼 바인딩을 수행합니다.
정적 링크와 동적 링크는 각각 맞는 상황이 있습니다. 실제 프로젝트에서는 둘을 함께 사용하는 경우도 있습니다. 일부는 정적 링크에, 다른 일부는 동적 링크에 의존하도록 나누는 것입니다.
8. 운영체제 로딩: 프로그램을 실행 가능한 상태로 만들기
링커가 실행 파일을 생성한 뒤에도 프로그램이 저절로 실행될 수는 없습니다. 운영체제가 프로세스를 생성하고, 프로그램을 그 프로세스의 가상 주소 공간에 매핑해야 합니다.
Linux에서 새 프로그램을 실행할 때 일반적으로는execve 시스템 호출을 사용합니다.
execve성공하면 현재 프로세스의 프로그램 이미지가 새 프로그램의 이미지로 대체됩니다. 단순히 새 프로세스를 새로 만드는 과정은 아닙니다.
8.1 ELF 로딩 과정
Linux 커널은 실행 파일의 ELF 정보를 해석하고, 프로그램 헤더(Program Header)에 따라 매핑해야 할 세그먼트를 결정한 뒤 해당 가상 메모리 영역을 생성합니다.
여기서 ELF의 Section과 Segment를 구분해야 합니다:
운영체제가 프로그램을 로드할 때关注的하는 것은 Program Header가 기술한 Segment이며, Section을 하나씩 단순히 로드하는 것은 아닙니다.
일반적인 과정은 다음과 같이 정리할 수 있습니다:
동적 링크 방식의 프로그램에서는 커널이 보통 ELF 정보를 바탕으로 동적 링커를 찾아 먼저 제어권을 넘깁니다. 동적 링커가 필요한 공유 라이브러리 로드와 재배치를 마친 뒤에 프로그램 진입점으로 제어권을 넘깁니다.
정적 링크 방식의 프로그램에서는 이 과정에 통상적인 동적 링커가 개입할 필요가 없습니다.
8.2 CPU가 실제로 실행을 시작한다
프로그램 이미지와 실행 환경이 준비되면, 프로세서는 진입 주소에서 명령어 실행을 시작합니다.
CPU의 기본 동작은 다음과 같이 추상화할 수 있습니다:
이것이 기계 명령어가 프로세서의 실행 단계에 들어간 뒤의 기본 흐름입니다. 현대 CPU가 내부에서 파이프라인, 비순차 실행, 분기 예측을 통해 어떻게 성능을 높이는지는 뒤에서 다룹니다.
9. 언어마다 실행 경로가 같지는 않다
앞에서는 주로 C 언어로 네이티브 컴파일 도구 체인을 설명했지만, 모든 언어가 대상 CPU의 기계 코드를 직접 생성하는 것은 아닙니다.
언어마다 서로 다른 실행 모델을 사용할 수 있습니다.
9.1 C / C++: 일반적으로 AOT 컴파일을 사용한다
C와 C++는 일반적으로 선행 컴파일(Ahead-of-Time, AOT)을 통해 대상 플랫폼의 기계 코드를 생성합니다.
프로그램은 실행되기 전에 이미 주요 기계 코드 생성을 마칩니다. 실행 시점에는 여전히 동적 라이브러리, 런타임 라이브러리, 운영체제 서비스에 의존할 수 있습니다.
9.2 Java: 바이트코드와 JVM
Java는 일반적으로 먼저 소스 코드를 JVM 바이트코드로 컴파일합니다:
컴파일하면.class 파일이 생성되며, 그 안에는 x86-64나 ARM64를 직접 겨냥한 기계 코드가 아니라 JVM 바이트코드가 들어 있습니다.
JVM은 바이트코드를 인터프리트해 실행할 수도 있고, 런타임 전략에 따라 핫스팟 코드를 네이티브 기계 코드로 컴파일할 수도 있습니다. 어떤 방식을 택하고 언제 전환하는지는 JVM 구현과 런타임 전략이 결정합니다.
따라서 Java 바이트코드는 특정 물리 CPU의 ISA가 아니라, JVM이 정의한 가상 명령어 체계입니다.
9.3 Go: 일반적으로 네이티브 기계 코드를 생성한다
Go는 일반적으로 컴파일러를 통해 미리 대상 플랫폼의 기계 코드를 생성해 네이티브 실행 파일을 만듭니다.
Go 프로그램에는 보통 Go runtime이 포함되며, 이는 가비지 컬렉션, goroutine 스케줄링, 일부 메모리 관리, 런타임 서비스 등의 기능을 지원합니다.
따라서 Go는 일반적으로 네이티브 기계 코드를 직접 생성하지만, 프로그램 실행에는 여전히 런타임 환경이 필요합니다.
10. 교차 컴파일: 한 대의 머신에서 다른 아키텍처의 프로그램을 만든다
목표 ISA와 컴파일러 백엔드를 이해하고 나면 교차 컴파일(Cross Compilation)을 한 걸음 더 깊이 이해할 수 있습니다.
교차 컴파일이란 한 플랫폼에서 컴파일러를 실행하면서도 다른 플랫폼을 대상으로 프로그램을 생성하는 것을 말합니다.
예를 들어 x86-64 Linux 머신에서 ARM64 Linux 프로그램을 컴파일하는 경우입니다.
이때 컴파일러가 실행되는 환경과 대상 프로그램의 실행 환경은 서로 다릅니다.
교차 컴파일은 임베디드 개발, 클라우드 빌드, 멀티 아키텍처 컨테이너 이미지, 운영체제 개발에 매우 중요합니다.
다만 교차 컴파일에서는 목표 ISA를 지정하는 것뿐 아니라 대상 운영체제, ABI, 시스템 라이브러리, 헤더 파일, 링커 같은 요소도 함께 고려해야 합니다. 올바른 아키텍처의 명령어를 생성했더라도 그 프로그램이 대상 기기에서 정상 동작한다고 보장할 수는 없습니다.
11. 전체 과정을 하나로 연결하기
이제 소스 코드에서 CPU 실행까지의 과정을 완전히 이어서 볼 수 있습니다:
각 단계는 서로 다른 문제를 해결합니다:
단계
핵심 작업
전처리
매크로, 헤더 파일, 조건부 컴파일 확장
컴파일러 프론트엔드
소스 코드의 구조와 의미 이해
IR과 최적화
통합 표현을 구축하고 프로그램 개선
컴파일러 백엔드
목표 ISA를 향한 명령어 생성
어셈블러
명령어를 기계 코드로 인코딩
링커
심볼 해석과 재배치 수행
운영체제 로더
프로세스 이미지와 실행 환경 구축
동적 링커
공유 라이브러리 로드와 필요한 바인딩 수행
CPU
명령어 인출, 해독, 기계 명령어 실행
12. 정리
프로그램이 소스 코드에서 CPU가 실행할 수 있는 기계 명령어로 바뀌는 과정은 단순한 텍스트 변환이 아니라, 컴파일, 인코딩, 링크, 로드로 이어지는 완전한 체인입니다.
이 체인을 이해하려면 다음 몇 가지 핵심 지점을 파악해야 합니다:
여기까지宏观적으로 ISA를 이해했고, 고급 언어가 어떻게 한 단계씩 기계 명령어로 바뀌는지도 알게 되었습니다.
다음 글에서는 구체적인 명령어 집합으로 들어가, x86-64를 예로 프로세서가 프로그램에 노출하는 레지스터, 명령어의 피연산자, 메모리 주소 지정 방식을 알아보고, 한 개의 기계 명령어가 실제로 무엇까지 표현할 수 있는지 더 깊이 이해하겠습니다.