62 함수 선언과 호출식 — 부르는 일의 안쪽

62.1 셋을 갈라 놓는다 — 선언, 정의, 호출식#

같은 이름이 세 자리에 나온다. 세 자리가 하는 일은 전혀 다르다.

선언은 약속이고, 정의는 물건이고, 호출식은 사건이다. 이 장은 셋째 — 사건 — 을 주로 다루지만, 사건이 제대로 일어나려면 앞의 둘이 서로 어긋나지 않아야 한다. 어긋나도 컴파일러가 아무 말을 못 하는 경우가 있고, 그것이 이 언저리에서 가장 험한 사고를 낸다(57장).

62.1.1 호출식은 연산자다#

add(2, 3) 을 「함수를 부르는 문법」이라고만 보면 놓치는 것이 있다. C 문법에서 이것은 후위 연산자 () 를 쓴 식이고, 피연산자가 둘로 갈린다.

이 사실에서 바로 따라 나오는 결과가 있다. 함수 지시자 자리에 식이 올 수 있으므로, 그 식 자체에도 부수효과가 있을 수 있다 — tbl[i++](x) 처럼. 그리고 함수 이름은 쓰이는 순간 함수 포인터로 무너지므로(64장), add(2,3) 과 (*add)(2,3) 과 (&add)(2,3) 은 모두 같은 뜻이다.

★ 쉼표로 나눈 인자 목록의 쉼표는 쉼표 연산자가 아니다. f(a, b) 는 인자 둘이고, f((a, b)) 는 인자 하나다 — 안쪽 괄호 속의 쉼표가 그제야 연산자가 되어 a 를 평가해 버리고 b 를 값으로 준다. 매크로가 인자를 세는 방식도 이 구분을 따른다(61장).

62.1.2 C23 이 정리한 옛 자리#

원형 없는 함수는 오래된 C 의 유산이었다. C23 이 그 유산을 걷어 냈다.

이 기계의 gcc 로 확인하면 차이가 그대로 드러난다. static int f() { return 1; } 를 두고 f(2) 를 부르면 -std=c17 에서는 아무 말이 없지만 -std=c23 에서는 too many arguments to function 'f' 로 잘린다. 빈 괄호가 「모른다」에서 「없다」로 바뀐 것이다.

★ 반대 방향의 어긋남도 있다. 표의 둘째 줄 — 선언 없는 호출 — 은 C23 이 오류로 정한 것인데, 이 기계의 gcc 14 는 -std=c17 에서도 이미 오류로 낸다. 표준이 정하기 전에 컴파일러가 먼저 막은 것이다.

★ 「없앴다」와 「컴파일러가 거부한다」는 다르다. 옛 정의 형식은 표준에서 사라졌지만 이 기계의 gcc 는 -std=c23 에서도 경고 하나(-Wold-style-definition) 로 받아 준다 — 옛 코드를 살려 두려는 배려다. 반면 clang 은 같은 자리에서 오류를 낸다. 표준이 무엇을 없앴는가와 내 컴파일러가 무엇을 받아 주는가는 따로 확인해야 한다.

62.2 인자는 대입하듯 들어간다#

원형이 있으면 컴파일러는 인자 하나하나를 매개변수 타입으로 대입하듯 바꾼다(30장). 반환값도 마찬가지로 반환 타입으로 바뀐다. 소리 없이 일어나는 일이라 눈으로 한 번 봐 두는 편이 좋다.

// 원형이 있으면 인자는 "대입하듯" 변환되어 들어간다.
#include <stdio.h>

static void takes_int(int n)
{
    printf("  the parameter holds %d\n", n);
}

static void takes_unsigned(unsigned n)
{
    printf("  the parameter holds %u\n", n);
}

// 반환값도 마찬가지다 --- 돌려주는 식은 반환 타입으로 변환된다.
static int truncating_return(void)
{
    return (int)3.99;              // 명시적으로 적어 두면 읽는 사람이 안다
}

static char narrowing_return(void)
{
    int wide = 321;
    return (char)wide;             // 321 은 char 에 들어가지 않는다
}

int main(void)
{
    puts("a double handed to an int parameter:");
    takes_int(3.7);                // 3 으로 잘려서 들어간다

    puts("a negative int handed to an unsigned parameter:");
    takes_unsigned(-1);            // 감싸 올라간다

    printf("returning 3.99 as int: %d\n", truncating_return());
    printf("returning 321 as char: %d\n", narrowing_return());

    // 원형이 없으면 이 조율이 일어나지 않는다. C23 부터는 원형 없는 호출
    // 자체가 오류이므로, 남은 "조율 없는 자리"는 ... 뿐이다.
    return 0;
}

a double handed to an int parameter:
  the parameter holds 3
a negative int handed to an unsigned parameter:
  the parameter holds 4294967295
returning 3.99 as int: 3
returning 321 as char: 65

3.7 이 3 이 되어 들어가고, -1 이 unsigned 자리에서 감싸 올라가고, 321 이 char 로 좁혀지며 65 가 된다. 어느 것도 오류가 아니다 — 대입이 그러하듯 조용히 변환될 뿐이다.

배열이 무너지는 자리는 특히 자주 데인다. 매개변수에 int a[10] 이라 적어도 받는 것은 포인터 하나다.

// 매개변수에 적은 것과 실제로 받는 것은 다를 수 있다.
#include <stdio.h>

// [10] 이라고 적었지만 받는 것은 포인터 하나다.
// (여기서 sizeof a 를 쓰면 gcc 가 -Wsizeof-array-argument 로 나무란다.)
static void looks_like_array(int a[10])
{
    int *p = a;                    // 같은 것이다 --- 대입에 경고가 없다
    printf("  inside: sizeof(the parameter) = %zu\n", sizeof p);
}

// 이렇게 적어야 "적어도 10개는 있다"가 계약이 된다 (C99 부터).
static int sum_ten(int a[static 10])
{
    int total = 0;
    for (int i = 0; i < 10; i++)
        total += a[i];
    return total;
}

// 길이를 따로 받는 것이 정석이다.
static int sum_n(const int *a, size_t n)
{
    int total = 0;
    for (size_t i = 0; i < n; i++)
        total += a[i];
    return total;
}

int main(void)
{
    int v[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

    printf("outside: sizeof(v) = %zu\n", sizeof v);
    looks_like_array(v);
    printf("  the array itself never crossed the call --- only its address did\n");

    printf("sum via [static 10]: %d\n", sum_ten(v));
    printf("sum via pointer+length: %d\n", sum_n(v, sizeof v / sizeof v[0]));
    return 0;
}

outside: sizeof(v) = 40
  inside: sizeof(the parameter) = 8
  the array itself never crossed the call --- only its address did
sum via [static 10]: 55
sum via pointer+length: 55

바깥에서 40바이트였던 것이 안에서는 8바이트다 — 배열은 호출을 건넌 적이 없다. 넘어간 것은 주소뿐이다. 그래서 안쪽에서 sizeof 로 길이를 알아내려는 시도는 헛되고, gcc 는 아예 이 자리를 짚어 준다: 'sizeof' on array function parameter 'a' will return size of 'int *'.

★ int a[static 10] 은 다르다. 여전히 받는 것은 포인터지만, 「적어도 10개는 있다」가 계약으로 적힌다(53장). 컴파일러는 이 약속을 근거로 최적화하고, 어기면 미정의 동작이다 — 약속을 적는 자리이지 검사를 붙이는 자리가 아니다.

62.3 순서 — 표준이 정하지 않은 것#

이제 이 장의 첫 매듭이다. 한 호출식 안에서 인자들은 어떤 순서로도 평가될 수 있다. 실물로 본다.

// 인자가 평가되는 순서는 표준이 정해 두지 않았다.
// 같은 소스가 컴파일러마다 다른 순서로 돌 수 있다.
#include <stdio.h>

static int step = 0;

// 부르면 자기 이름을 찍고 몇 번째로 불렸는지를 돌려준다.
static int mark(const char *who)
{
    step += 1;
    printf("  evaluated %s (step %d)\n", who, step);
    return step;
}

static void take(int a, int b, int c)
{
    printf("  the callee got a=%d b=%d c=%d\n", a, b, c);
}

int main(void)
{
    puts("call with three arguments:");
    take(mark("the first argument"),
         mark("the second argument"),
         mark("the third argument"));

    // 한 인자 *안에서*의 순서는 또 다른 이야기다.
    step = 0;
    puts("one argument built from two calls:");
    take(mark("left of +") + mark("right of +"), 0, 0);
    return 0;
}

call with three arguments:
  evaluated the third argument (step 1)
  evaluated the second argument (step 2)
  evaluated the first argument (step 3)
  the callee got a=3 b=2 c=1
one argument built from two calls:
  evaluated left of + (step 1)
  evaluated right of + (step 2)
  the callee got a=3 b=0 c=0

이 기계의 gcc 는 마지막 인자부터 거꾸로 평가했다. 같은 소스를 clang 으로 빌드하면 첫 인자부터 순서대로 평가한다. 최적화 수준을 -O0·-O2·-Os 로 바꿔 봐도 각자의 버릇은 그대로였다.

여기서 두 가지를 갈라 읽어야 한다.

순서가 갈리는 것 자체는 사고가 아니다. 인자를 평가하는 순서는 미지정이고, 어느 쪽을 골라도 프로그램은 정의된 대로 돈다 — 다만 내가 기대한 순서에 기대어 쓴 코드가 무너질 뿐이다. 실제로 위 시연의 둘째 부분을 보면, 바깥 인자는 거꾸로 가면서 한 인자 안쪽의 두 호출은 소스 순서대로 갔다. 「이 컴파일러는 오른쪽부터 한다」는 요약조차 정확하지 않은 것이다.

값을 두 번 고치는 것은 사고다. show(i++, i++) 는 한 값을 순서 없이 두 번 고치므로 미정의 동작이다. 위 표의 a=1 b=0 과 a=0 b=1 은 「두 답 중 하나」가 아니라 「아무 답이나 나와도 되는 자리에서 나온 두 예」다.

printf("%d %d\n", i, i++);     /* 미정의 동작 */
put(buf[k], buf[k++]);          /* 미정의 동작 */

int before = i;
i += 1;
printf("%d %d\n", before, i);

62.3.1 순서가 있는 자리#

전부 자유로운 것은 아니다. 호출과 호출 사이에는 분명한 규율이 있다.

마지막 줄이 중요하다. f(g(), h()) 에서 g 와 h 중 누가 먼저인지는 모르지만, g 의 절반이 돌다가 h 로 넘어갔다 되돌아오는 일은 없다. 순서는 미지정이되 뒤섞임은 금지다. 표준이 이 관계에 따로 이름을 붙여 둘 만큼 중요한 보장인데 — 순서는 확정되지 않았지만 하나씩 차례로 일어난다는 뜻으로 「부정 순서」 (indeterminately sequenced)라 부른다 — 이것이 없으면 재진입하지 않는 함수를 인자 자리에서 부르는 일이 전부 위험해진다.

62.4 한 번의 호출, 다섯 걸음#

이제 사건의 안쪽이다. add(2, 3) 한 줄이 기계 수준에서 무엇을 시키는가.

②의 「돌아올 주소」가 함수라는 장치의 심장이다. 이 주소가 스택에 남기 때문에 호출은 겹겹이 쌓일 수 있고, 재귀가 성립하고, 그리고 — 그 자리를 넘어 쓰면 프로그램이 남의 주소로 돌아간다(44장).

③에서 갈리는 또 하나의 약속이 누가 무엇을 지키는가다.

이 구분이 있어야 호출이 싸진다. 모든 레지스터를 매번 저장하면 호출 한 번이 수십 번의 기억 접근이 된다. 절반씩 나눠 맡기면 대개는 아무것도 저장하지 않고 지나간다.

62.5 레지스터인가 스택인가 — 예산이 있다#

인자를 레지스터로 보내면 빠르다. 그러나 레지스터는 유한하다. 그래서 모든 호출 규약은 예산을 정해 둔다 — 몇 개까지 레지스터로 보내고, 그 뒤는 스택으로 보낸다.

C 에는 「이 인자는 레지스터로 왔다」를 묻는 문법이 없다. 그래도 간접적으로 볼 수는 있다. 최적화를 끄면 레지스터로 받은 인자는 함수가 자기 프레임에 나란히 내려놓고, 스택으로 실려 온 인자는 부른 쪽이 놓아 둔 자리를 그대로 쓴다. 두 무리는 멀리 떨어져 있으므로 이웃한 인자의 주소 차이를 재면 경계가 드러난다.

// 인자는 어디에 놓여 있는가 --- 레지스터로 온 것과 스택으로 온 것.
//
// C 에는 "이 인자는 레지스터로 왔다"를 묻는 문법이 없다. 그러나 최적화를
// 끄면 컴파일러는 레지스터로 받은 인자를 자기 프레임에 나란히 내려놓고,
// 스택으로 실려 온 인자는 호출한 쪽이 놓아 둔 자리를 그대로 쓴다. 두
// 무리는 서로 멀리 떨어져 있으므로, *이웃한 인자의 주소 차이*를 재면
// 경계가 어디인지 드러난다.
#include <stdio.h>
#include <stdint.h>
#include <stddef.h>

static void eight(int a, int b, int c, int d, int e, int f, int g, int h)
{
    const int *arg[8] = { &a, &b, &c, &d, &e, &f, &g, &h };
    ptrdiff_t widest = 0;
    int at = 0;

    for (int i = 0; i + 1 < 8; i++) {
        uintptr_t p = (uintptr_t)arg[i], q = (uintptr_t)arg[i + 1];
        ptrdiff_t gap = p > q ? (ptrdiff_t)(p - q) : (ptrdiff_t)(q - p);
        printf("  argument %d to %d: %td bytes apart\n", i + 1, i + 2, gap);
        if (gap > widest) { widest = gap; at = i + 1; }
    }
    printf("the widest jump is between argument %d and %d\n", at, at + 1);
}

int main(void)
{
    puts("a call with eight arguments:");
    eight(1, 2, 3, 4, 5, 6, 7, 8);
    puts("that jump is the seam between the register group and the stack group.");
    return 0;
}

a call with eight arguments:
  argument 1 to 2: 4 bytes apart
  argument 2 to 3: 4 bytes apart
  argument 3 to 4: 4 bytes apart
  argument 4 to 5: 4 bytes apart
  argument 5 to 6: 4 bytes apart
  argument 6 to 7: 152 bytes apart
  argument 7 to 8: 8 bytes apart
the widest jump is between argument 6 and 7
that jump is the seam between the register group and the stack group.

여섯째와 일곱째 사이에서 자리가 크게 뛴다. 그 자리가 이 ABI(application binary interface) 의 정수 인자 예산 — 여섯 — 이 끝나는 지점이다. 같은 프로그램을 clang 으로 빌드해도 뛰는 폭은 달랐지만 뛰는 자리는 같았다. 컴파일러의 취향이 아니라 규약이 정한 경계이기 때문이다.

윈도의 「그림자 공간」은 레지스터로 인자를 받은 함수가 그것을 내려놓을 자리를 부르는 쪽이 미리 비워 두는 약속이다. 인자가 하나도 없어도 32바이트를 비운다. 같은 CPU 에 같은 기계어인데 약속이 다른 것이다(57장).

62.5.1 치우는 쪽이 갈리면 이름도 갈린다#

32비트 윈도에는 규약이 여럿 공존했다. 인자를 스택에 쌓는 것은 같은데 누가 치우는가가 달랐고, 그래서 잘못 이으면 스택이 조용히 어긋난다. 그 시절의 해법이 이름에 흔적을 남기는 것이었다.

ret $8 한 줄이 「돌아가면서 스택 8바이트도 함께 걷는다」는 뜻이다. 그리고 이름 뒤의 @8 덕분에, 인자 개수가 다른 선언으로 잘못 부르면 링커가 이름을 못 찾는다 — 조용한 파손 대신 링크 오류가 난다. 이름 장식이 안전 장치 노릇을 한 드문 예다.

62.6 기묘한 사례들 — ARM 과 임베디드#

책상 위의 규약만 보면 「예산이 몇 개인가」 정도의 차이로 보인다. 작은 기계로 내려가면 훨씬 기묘한 규칙들이 나온다. 아래는 모두 한 줄의 같은 선언을 서로 다른 표적으로 빌드해 확인한 것이다.

long long mix(int a, long long b, int c);   /* mix(1, 2, 3) 을 부른다 */

62.7 구조체를 주고받을 때#

값 하나가 레지스터에 안 들어가면 어떻게 되는가. 구조체가 그 경계에 있다.

큰 구조체를 값으로 주고받는 코드는 소스에서 한 글자도 그런 티를 내지 않지만, 실제로는 복사와 숨은 인자가 따라붙는다. 그래서 성능이 걸린 자리에서는 포인터로 넘기고 const 를 붙이는 관용구가 자리 잡았다(48장).

★ 「16바이트 이하면 레지스터」 같은 어림은 규약마다 다르고 예외도 많다 — 구조체 안에 실수와 정수가 섞이면 SysV 는 8바이트 조각별로 갈래를 매겨 어떤 조각은 정수 레지스터로, 어떤 조각은 실수 레지스터로 보낸다. 이 규칙을 외울 필요는 없다. 외울 것은 하나다 — 값의 크기와 구성이 실려 가는 방식을 바꾼다.

62.8 함수 포인터를 돌려주는 함수#

호출식의 함수 지시자 자리에 식이 올 수 있다면, 그 식을 함수가 만들어 줄 수도 있다. 선언자를 읽는 연습으로도 좋은 자리다.

// 함수 포인터를 돌려주는 함수 --- 같은 것을 세 가지 표기로 적는다.
#include <stdio.h>

static int add(int a, int b) { return a + b; }
static int mul(int a, int b) { return a * b; }

// ① 날것의 선언자. 안쪽부터 읽는다:
//    pick 은 (char) 를 받는 함수이고, 그 결과는
//    (int, int) 를 받아 int 를 주는 함수를 가리키는 포인터다.
static int (*pick(char op))(int, int)
{
    return op == '+' ? add : mul;
}

// ② 이름을 붙여 두면 같은 뜻이 한 줄로 읽힌다.
typedef int binop(int, int);      // 함수 타입
static binop *pick_typedef(char op)
{
    return op == '+' ? add : mul;
}

// ③ 반환 타입만 이름 붙이는 흔한 절충.
typedef int (*binop_ptr)(int, int);
static binop_ptr pick_ptr(char op)
{
    return op == '+' ? add : mul;
}

int main(void)
{
    printf("raw declarator: %d\n", pick('+')(3, 4));
    printf("function typedef: %d\n", pick_typedef('*')(3, 4));
    printf("pointer typedef: %d\n", pick_ptr('+')(10, 32));

    // 돌려받은 포인터는 값이므로 변수에 담아 두었다가 나중에 불러도 된다.
    binop_ptr f = pick('*');
    printf("stored and called later: %d\n", f(6, 7));

    // (*f)(...) 와 f(...) 는 같은 뜻이다 --- 이름은 어차피 포인터로 무너진다.
    printf("both spellings agree: %d %d\n", (*f)(2, 3), f(2, 3));
    return 0;
}

raw declarator: 7
function typedef: 12
pointer typedef: 42
stored and called later: 42
both spellings agree: 6 6

가장 안쪽 것부터 읽는다. int (*pick(char op))(int, int) 에서 pick 은 char 하나를 받는 함수이고, 그 결과는 포인터이며, 그 포인터가 가리키는 것은 int 둘을 받아 int 를 주는 함수다.

62.9 여기서 잘 나는 사고들#

이 장의 규칙이 어긋나는 자리를 한자리에 모은다. 대부분 컴파일러가 잡아 주지만, 잡아 주지 못하는 것이 몇 개 있고 그것들이 험하다.

셋째 줄이 이 표에서 가장 위험하다 — 아무도 잡아 주지 않는 자리이기 때문이다.

// 두 파일이 같은 함수를 서로 다르게 알고 있다.
//
// 경고: 이 프로그램은 미정의 동작이다. 컴파일러도 링커도 아무 말을 하지
// 않는다 --- 각자 자기 파일만 보기 때문이다. 아래 출력은 "옳은 결과"가
// 아니라 이 기계의 호출 규약에서 우연히 맞아떨어진 모습일 뿐이다.
#include <stdio.h>

// 정의는 int 둘인데 여기서는 long 둘이라고 선언했다.
void report(long id, long value);

int main(void)
{
    puts("calling a function this file has mis-declared:");
    report(1, 2);
    puts("it linked, it ran, and it even looks right --- that is the danger.");
    return 0;
}

calling a function this file has mis-declared:
  report() as defined here: int id=1, int value=2
it linked, it ran, and it even looks right --- that is the danger.

두 파일은 서로를 본 적이 없다. 컴파일러는 각자 자기 파일만 보고, 링커는 이름만 본다 — report 라는 이름이 있고, 누군가 그것을 부른다, 끝이다. 그래서 이 프로그램은 경고 하나 없이 빌드되고, 이 기계에서는 심지어 맞는 답을 찍는다. long 으로 보낸 값을 int 로 받았는데, 이 규약에서는 같은 레지스터의 아래쪽 절반을 읽는 것이라 우연히 들어맞은 것이다.

우연이 깨지는 자리도 같은 이유로 설명된다. 만약 정의가 void report(double) 이고 선언이 void report(long) 이었다면, 부르는 쪽은 값을 정수 레지스터에 싣고 불린 쪽은 실수 레지스터를 읽는다 — 아무도 쓴 적 없는 자리를. 값이 크게 틀리는 것이 아니라 아예 무관한 수가 나온다.

/* a.c */                    /* b.c */
void report(long, long);     void report(int id, int value) { … }

62.10 되짚기#

이 장은 「원형이 있고, 개수와 타입이 맞는」 호출을 전제로 했다. 다음 장은 그 전제가 무너지는 자리다 — 받는 쪽이 인자의 개수도 타입도 모르는 함수, 가변 인자 함수다. 이 장에서 본 조율이 사라지면 무엇을 대신 약속해야 하는지가 그 장의 이야기다.