🐢 chap2. 소스 코드에서 이진 파일로

Posted Oct 8, 2023

By 이가은 28 min read

⭐ 2.1 표준 컴파일 파이프라인

네 가지 요소로 구성된 파이프라인

전처리기
컴파일러
어셈블러
링커
- 파이프라인 내부의 각 컴포넌트는 이전 요소로부터 특정한 입력값을 받고, 다음 컴포넌트를 위한 특정 결괏값을 생성합니다.
- 컴포넌트 중 어느 작은 한 단계라도 실패한다면 이는 컴파일 실패 또는 링크 실패로 이어지고, 그에 관련된 오류 메시지가 등장합니다.
  - 재배치 가능한 목적파일과 같은 어떤 중간 결과물은 소스파일 하나가 세 가지 요소(전처리기, 컴파일러, 어셈블러)만 성공적으로 통과하면 만들어집니다.
  - 링커는 더 큰 결과물을 만들 때 사용하는데, 실행 가능한 목적 파일이라고 합니다. 소스 파일을 빌드하면 하나 또는 여러개의 목적파일을 만들 수 있습니다.
플랫폼
하드웨어에서 실행되는 운영체제의 결합.
- 크로스 플랫폼와 이식 가능한의 차이점 : 크로스 플랫폼은 각 플랫폼에 따라 다른 이진파일과 인스톨러가 있습니다. 이식 가능한 소프트웨어는 모든 플랫폼에서 같은 이진 파일과 인스톨러를 사용합니다.
  - gcc와 clang 같은 C컴파일러는 크로스 플랫폼, 자바의 바이트 코드는 이식 가능합니다.
  - C/C++코드가 이식 가능하다 함은 소스 코드에 어떤한 변경이나 수정을 거치지 않고 서로 다른 플랫폼에서 컴파일 할 수 있다는 말입니다. 그러나 최종 목적파일에 이식성이 있다는 의미는 아닙니다.

2.1.1 프로젝트 빌드하기

☑️ 헤더 파일 vs 소스 파일

헤더 파일 : 확장자가 .h인 파일
소스 파일 : 확장자가 .c인 파일

헤더 파일은 주로 열거형, 매크로, 형식 정의, 함수의 선언, 전역 변수, 구조체도 포함합니다. 프로그래밍 요소의 선언을 파일에 정리해둡니다.

※소스 파일 안에 다른 소스 파일을 포함하는 것은 잘못된 경우입니다.

함수 선언은 반환형과 함수 시그니처로 구성됩니다.

  
dobule average(int*, int);

☑️함수 정의

  
double average(int* array, int length){
	if(length <= 0 ){
		return 0;
	}
	double sum = 0.0;
	for(int i = 0; i<length; i++){
		sum += array[i];
	}
	return sum/ length;
}

중괄호로 감싸인 몸체가 있으면 정의입니다.

main함수
소스 파일 중 하나는 main 함수를 포함하는데, 프로그램의 진입점입니다. main함수 없이는 프로그램의 실행 파일을 가질 수 없습니다. 컴파일러는 프로그램 시작점으로 main을 찾습니다.
전방 선언
함수를 정의하기 이전에 함수를 선언하는 행위
헤더 가드문
헤더 파일이 컴파일 될 때 두 번 또는 그 이상 포함되는 것을 방지합니다.
규칙 1 : 소스 파일만 컴파일, 헤더파일은 컴파일 하지 않는다.
규칙 2 : 각 소스 파일을 따로따로 컴파일 합니다., 한 번에 여러 파일을 컴파일 하지 않습니다.

☑️ 2.1.2 1단계 : 전처리

컴파일 파이프라인의 첫 단계 : 전처리 입니다. 컴파일이 시작되기 전에 전처리기가 헤더 파일의 내용을 모아서 하나의  C코드 몸체로 만듭니다. 그리고, 전처리기 지시자(#include, #define등)는 이 단계에서 반드시 해결되어야 합니다. 전처리된 코드는 변환단위라고 합니다. 변환단위는 컴파일 단위라고도 합니다.

```c
$ gcc -E ExtremeC_examples_chapter2_1.c
변환단위 생성
```

입력값 : 소스 파일, 출력값 : 변환단위

2.1.3 2단계 : 컴파일
입력값: 변환단위, 출력값: 어셈블리 코드
컴파일러는 변환단위를 구문 분석parse하고 이를 대상 아키텍처에 맞는 어셈블리 코드로 변환합니다.
대상 아키텍처(호스트 아키텍처) : 프로그램이 컴파일되어 실행될 하드웨어나 CPU를 뜻합니다.
1 2 3 $ gcc -S ExtermeC_examples_chapter2_1.c $ cat ExtemreC_examples_chapter2_1.s 컴파일 이후 보여진 어셈블리 코드 P107
대상 아키텍처 : 소스 파일이 컴파일되어 실행될 아키텍처
빌드 아키텍처 : 소스를 컴파일 할 때 사용하는 아키텍처
예를 들어 : ARM 32 비트 머신(빌드아키텍처)에서 AMD 64비트 하드웨어(대상 아키텍처)를 위한 C소스를 컴파일 할 수 있습니다.
2.1.4 3단계: 어셈블리
입력값 : 어셈블리 코드 출력값 : 재배치 가능 한 목적파일 ( 기계어 코드, 중간 목적 파일)
목적 파일 : 기계 수준의 명령어를 포함하는 파일을 목적파일 이라한다.
이진 파일 또는 목적파일 기계 수준의 명령어를 포함하는 파일을 가리키는 서로 같은 말이다.
유닉스 계열 운영체제에서 어셈블러 도구는 as입니다.
1 2 $ as ExtemreC_examples_chapter2_1.s -o ExtemreC_examples_chapter2_1.o $
어셈블리코드로 목적파일을 생성
재배치 가능한 목적 파일은 .o확장자(윈도우에서는 .obj)을 붙입니다.
컴파일러로 -c옵션을 전달한다면 전처리, 컴파일, 어셈블리를 한번에 수행합니다.
빌드는 4단계(전처리, 컴파일, 어셈블리, 링크)를 의미합니다.
1 2 3 $ gcc -c ExtremeC_examples_chapter2_1.c -o impl.o $ gcc -c ExtremeC_examples_chapter2_1_main.c -o main.o $
소스파일에서 재배치 가능한 목적파일 생성
2.1.5 4단계: 링크
입력값 : 목적파일 결과값 : 실행파일
새로운 아키텍처를 위한 프로그램은 2가지 조건을 충족하면 빌드 할 수 있습니다.
1. 어셈블리어가 알려져 있습니다.
2. 제조사에 의해 개발된 필수 어셈블러 도구가 있어야 합니다. 이를 사용해 어셈블리 코드를 그에 해당하는 기계어 수준 명령어로 변환할 수 있습니다.
이 두 조건이 만족하면 소스 코드에서 기계수준의 명령어를 생성할 수 있습니다. 그래야 목적 파일 포맷을 이용해 목적 파일 안에 기계 수준의 명령어를 저장할 수 있습니다. 예를 들면 ELF또는 Mach-O라는 형태가 될 수 있습니다.
기본링커 ld 사용하기
1 2 3 4 $ ld impl.o main.o 113쪽 $ gcc impl.o main.o $ ./a.out

⭐ 1.2 포인터 변수

1.2.1 문법

포인터: 메모리 주소를 저장하는 단순한 변수

예제 1-9

  
  int main(int argc, char** argv) {
    int var = 100;
    int* ptr = 0;
    ptr = &var;
    *ptr = 200;
    return 0;
  }

널 포인터 선언, 참조 연산자&, 역참조 연산자*

NULL 매크로 사용: 변수와 포인터를 더 쉽게 구분

1.2.2 포인터 변수의 산술연산

산술연산 간격: 포인터가 1씩 증감할 때 움직이는 바이트의 숫자, C 자료형에 의해 결정됨

예제 1-10

  
  #include <stdio.h>
    
  int main(int argc, char** argv) {
    int var = 1;
    
    int* int_ptr = NULL; // 포인터를 널로 만들기
    int_ptr = &var;
    
    char* char_ptr = NULL;
    char_ptr = (char*)&var;
    
    printf("Before arithmetic: int_ptr: %u, char_ptr: %u\n",
            (unsigned int)int_ptr, (unsigned int)char_ptr);
    
    int_ptr++;    // 일반적으로 산술연산 간격은 4바이트
    char_ptr++;   // 1바이트의 산술연산 간격
    
    printf("After arithmetic: int_ptr: %u, char_ptr: %u\n",
            (unsigned int)int_ptr, (unsigned int)char_ptr);
    
    return 0;
  }

실행 결과 정수 포인터의 연산 간격은 4바이트, 문자열 포인터는 1바이트

1.2.3 제네릭 포인터

제네릭 포인터: void* 자료형의 포인터, 역참조 불가능

예제 1-13

  
  #include <stdio.h>
    
  int main(int argc, char** argv) {
   int var = 9;
   int* ptr = &var;
   void* gptr = ptr;
     
   printf("%d\n", *gptr);
     
   return 0;
  }

제네릭 포인터를 역참조하면 컴파일 오류가 생성됨

1.2.4 포인터의 크기

아키텍처에 따라 포인터의 크기가 다름

대상 아키텍처에서 sizeof 함수 사용

1.2.5 허상 포인터

충돌 또는 세그멘테이션 오류 발생

예제 1-15

  
  #include <stdio.h>
    
  int* create_an_integer(int default_value) {
    int var = default_value;
    return &var;
  }
    
  int main() {
    int* ptr = NULL;
    ptr = create_an_integer(10);
    printf("%d\n", *ptr);
    return 0;
  }

세그멘테이션 오류 상황, ptr 포인터가 할당이 해제된 var의 메모리 영역을 가리킴(허상 포인터)

⭐ 1.3 함수

☑️ 함수의 구조

함수: 이름과 입력 매개변수의 목록, 출력 결과의 목록을 가진 논리 상자

C 언어에서 함수는 단 하나의 값만을 반환

블로킹 함수: 호출된 함수가 종료되어야만 반환값을 호출자 함수가 받을 수 있음

논블로킹 함수: 콜백 메커니즘, 비동기 함수, 사건 기반 프로그래밍(EDP)

☑️ 설계의 중요성

로직을 작성 후 다양한 곳에서 여러 번 사용 가능

추상화: 기존의 다른 로직으로부터 일부를 숨김

☑️ 스택 관리

스택 세그먼트 → 모든 지역 변수, 배열, 구조체가 할당되는 기본 메모리의 위치.

스택 프레임 → 스택 세그먼트의 가장 위에 놓이고, 함수 로직이 실행됩니다. 호출이 끝나면 스택 프레임은 제거되며 직전 호출 함수로 계속 이어집니다.

스택 프레임 예시

  
  int main()
  {
  	func1();
  }
    
  void func1()
  {
  	func2();
  }
    
  void func2()
  {
    	
  }

스택 오버플로 → 스택에서는 메모리가 한정적입니다. 하지만 함수 호출을 너무 많이 실행해 스텍 프레임의 모든 스택 세그먼트를 다 써버린 경우에 발생합니다.

☑️ 값에 의한 전달 vs 참조에 의한 전달

C에는 참조가 없어, 참조에 의한 전달은 존재하지 않습니다.

오로지 값에 의한 전달만 존재합니다.

값에 의한 전달 함수 호출의 예

  
  #include <stdio.h>
    
  void swap(int, int);
    
  int main(void)
  {
  	int a = 5, b = 3;
  	printf("before) a = %d, b = %d\n", a, b);
  	swap(a, b);
  	printf("after) a= %d , b = %d\n", a, b);
  	return 0;
  }
    
  void swap(int num1, int num2)
  {
  	int temp = num1;
  	num1 = num2;
  	num2 = temp;
    
  	printf("swap) a = %d , b = %d\n", num1, num2);
  }
    
  /******************************************************
  before) a = 5, b = 3
  swap) a = 3 , b = 5
  after) a= 5 , b = 3
  *******************************************************/

포인터를 변수로 전달하는 것이 포인터에 의한 전달입니다.

포인터에 의한 함수 호출의 예

  
  #include <stdio.h>
    
  void func(int* a)
  {
  	int b = 9;
  	*a = 5;     //포인터 역참조
  	a = &b;
  }
    
  int main(void)
  {
  	int x = 3;
  	int* xptr = &x;
  	printf("the value before the call = %d \n", x);
  	printf("pointer value before the call = %p\n", xptr);
  	func(xptr);
  	printf("the value after the call = %d \n", x);
  	printf("pointer value after the call=%p \n", xptr);
  	return 0;
  }
    
  /******************************************************
  the value before the call = 3
  pointer value before the call = 0000007032AFF624
  the value after the call = 5
  pointer value after the call=0000007032AFF624
  *******************************************************/

위의 결과를 보면 포인터의 값은 함수 호출 이후에도 변하지 않습니다. 이는 포인터가 값에 의한 전달 인수로 전달되었음을 의미합니다. 포인터를 역참조하면 호출하는 쪽의 함수의 변수를 수정할 수 있도록 합니다.

⭐ 1.4 함수 포인터

☑️ 함수 포인터

→ 함수의 주소를 저장하며 함수를 간접적으로 호출할 수 있도록 구현합니다.

→ 이로인해 각각의 기능들을 파일별로 나뉘어 놓는 작업인 모듈화가 가능해 졌습니다.

함수 포인터 변수 선언 = int (*fptr) (int);
int - 해당 함수의 반환형
(*fptr) - 포인터 변수
(int) - 해당함수의 매개변수의 형태

다른 함수 여러 개를 호출하는 하나의 함수 포인터

  
  #include <stdio.h>
    
  int sum(int a, int b)     // 타입 별칭으로 해두는 편이 좋습니다.
  {
  	return a + b;
  }
    
  int subtract(int a, int b)
  {
  	return a - b;
  }
    
  int main()
  {
    
  	int(*func_ptr)(int, int);
  	func_ptr = NULL;          // 함수 포인터도 NULL로 초기화를 해주어야합니다.
    
  	func_ptr = &sum;
  	int result = func_ptr(5, 4);
  	printf("Sum = %d\n", result);
    
  	func_ptr = &subtract;
  	result = func_ptr(5, 4);
  	printf("subtract = %d\n", result);
    
  	return 0;
  }
    
  Sum = 9
  subtract = 1

여러개의 다른 함수를 호출하는 하나의 함수 포인터

  
  #include <stdio.h>
    
  typedef int bool_t;
  typedef bool_t(*less_than_func_t)(int, int);
    
  bool_t less_than(int a, int b)
  {
  	return a < b ? 1 : 0;
  }
    
  bool_t less_than_modular(int a, int b)
  {
  	return (a % 5) < (b % 5) ? 1 : 0;
  }
    
  int main(void)
  {
  	less_than_func_t func_ptr = NULL;
    
  	func_ptr = &less_than;
  	bool_t result = func_ptr(3, 7);
  	printf("%d\n", result);
    
  	func_ptr = &less_than_modular;
  	result = func_ptr(3, 7);
  	printf("%d\n", result);
  	return 0;
  }
    
  1
  0

⭐ 1.5 구조체

☑️ 왜 구조체인가?

→ 원시 자료형 (PDT) = 자료구조를 설계할 수 있고, 알고리즘을 작성 할 수 있습니다.

ex) int, double

→ 사용자 정의 자료형 (UDT) = 직접 정의한 자료형이 필요하고, 프로그래밍 언어의 자료형으로는 충분하지 않을 때 사용합니다. struct 키워드를 사용합니다.

ex) 구조체

(구조체는 하나 이상의 변수를 하나로 묶을 수 있는 복합 자료형이므로 기본 자료형 변수를 묶어서 새로운 자료형을 만든 것이기 때문에 사용자 정의 자료형으로 구분됩니다.)

→ 다양한 형태의 데이터를 처리할 때 유용합니다.

☑️ 왜 사용자 정의 자료형인가?

같은 대상에 서로 연관된 속성을 그룹으로 묶는것이 가독성이 좋습니다. 더 고수준의 로직, 인간 수준의 로직과 충분히 비슷하게 문제를 분석하려면 새로운 자료형이 필요합니다.

ex) 비즈니스 로직 -은행(고객, 잔고, 돈, 현금, 지불) 개념을 마주하고, 은행 로직을 개발하기 위해서는 개발자와 비즈니스 분석가는 협력하며 규칙, 로직, 용어집등을 공유해야합니다.

☑️ 구조체의 역할

구조체는 하나의 통합된 타입아래 관련된 값을 갭슐화 합니다.

ex) color_t (red, green,blue)

  
struct color_t {
	int red;
	int green;
	int blue;
};

→ 새로운 자료형 아래에 서로 관련이 있는 필드를 그룹으로 묶는 캡슐화 합니다. 그리고 나서 필요한 변수를 정의할 때 이 새로운 자료형을 사용합니다.

☑️ 메모리 레이아웃

메모리 레이아웃이 필요한 이유 → 값은 메모리에 저장되고, cpu는 이 값을 충분히 빠르게 읽고 쓸 수 있어야 합니다.

구조체 변수에 할당된 바이트 수 출력하기

  
  #include <stdio.h>
    
  struct sample_t {
      char first;
      char second;
      char third;
      short fourth;
  };
    
  void print_size(struct sample_t* var) {
      printf("Size: %lu bytes\n", sizeof(*var));
  }
    
  void print_bytes(struct sample_t* var) {
      unsigned char* ptr = (unsigned char*)var;
      for (int i = 0; i < sizeof(*var); i++, ptr++) {
          printf("%d ", (unsigned int)*ptr);
      }
      printf("\n");
  }
    
  int main(int argc, char** argv) {
      struct sample_t var;
      var.first = 'A';
      var.second = 'B';
      var.third = 'C';
      var.fourth = 765;
      print_size(&var);
      print_bytes(&var);
      return 0;
  }
    
  Size: 6 bytes
  65 66 67 0 253 2

sizeof(sample_t)는 6바이트를 반환합니다.

char형 3개 short형 1개 총 5바이트 입니다. 이는 메모리 정렬을 위해 바이트 67뒤에 0이 보이게 합니다. 0바이트는 현재 워드(cpu가 메모리에 접근할 때 읽는 특정 바이트의 수)를 완성하기 위해 추가되며, 네 번째 필드가 다음 워드에서 시작할 수 있도록 합니다.

이때 메모리 정렬이란 시작하는 바이트가 워드의 시작점에 있을 때, 이 변수는 메모리에 정렬 되었다고 합니다.

ex) char형인 first, second, third는 각각 1바이트이며 이들은 구조체 레이아웃의 첫번째 워드에 탑재 됩니다. 이후 fouth 는 2바이트 입니다. 만일 메모리 정렬이 되지 않는다면 첫번째 바이트는 첫번째 워드의 마지막 바이트가 되게 됩니다.
      
이를 방지하기 위해 첫번째 워드는 0바이트 하나가 패킹(메모리 값을 정렬)되어 있다고 할 수 있습니다.

메모리 정렬은 기본적으로 활성화가 되어 있습니다.

☑️ 중첩 구조체

복합 자료형 = 사용자 정의 자료형이고, 몇 개의 구조체를 중첩한 결과입니다.

몇가지 중첩 구조체

  
  #include <stdio.h>
    
  typedef struct {
  	int x;			//4byte
  	int y;			//4byte
  }point_t;			//8byte
    
  typedef struct {
  	point_t center;	//8byte
  	int radius;		//4byte
  }circle_t;			//12byte
    
  typedef struct {
  	point_t start;	//8byte
  	point_t end;	//8byte
  }line_t;			//16byte

3개의 구조체인 point_t와 circle_t, line_t가 존재합니다.

point_t 구조체는 오직 원시자료형으로만 구성된 단순한 사용자 정의 자료형이지만

다른 구조체들은 point_t 자료형의 변수를 포함한 복합 사용자 정의 자료형입니다.

☑️ 구조체 포인터

→ 사용자 정의 자료형의 포인터는 원시 자료형의 포인터와 동일합니다.

→ 구조체 변수 포인터가 구조체 변수의 첫 번째 필드의 주소를 가르킵니다.

메모리에서 동일한 바이트 주소를 가리키는 세 가지 자료형으로부터 얻는 3개의 포인터

  
  #include <stdio.h>
    
  typedef struct {
  	int x;
  	int y;
  }point_t;
    
  typedef struct {
  	point_t center;
  	int raduus;
  }circle_t;
    
  int main(void)
  {
  	circle_t c;
    
  	circle_t* p1 = &c;
  	point_t* p2 = (point_t*)&c;
  	int* p3 = (int*)&c;
    
  	printf("p1 = %p\n", (void*)p1);
  	printf("p2 = %p\n", (void*)p2);
  	printf("p3 = %p\n", (void*)p3);
  	return 0;
  }
    
  p1 = 00000039EEB9F738
  p2 = 00000039EEB9F738
  p3 = 00000039EEB9F738

point_t와 circle_t 자료형의 포인터는 구조체의 변수의 첫번째 필드인 x의 주소를 가리켰습니다.

typedef를 사용하면 구조체의 새 별칭 타입을 선언 할 수 있습니다. 이는 추후에 struct 키워드를 사용하지 않고 변수를 사용할 수 있습니다.

전문가를 위한 C, chap2. 소스 코드에서 이진 파일로

This post is licensed under CC BY 4.0 by the author.