주의:

LLM으로 작성한 글입니다. 글에 틀린 내용이 있을 수 있습니다.

제가 아직 Ada, Rust 관련 글의 내용을 검증할 수준이 못됩니다.

개요

이 문서는 Ada와 Rust에서 C 바인딩을 오버헤드 없이(Zero-Overhead) 구현하는 방법을 기술적으로 설명합니다. 여기서 “오버헤드 없음”이란 C 함수 호출과 동일한 수준에서 추가적인 런타임 변환, 복사, 마샬링이 발생하지 않고, 호출 규약과 데이터 레이아웃이 완전히 일치하는 상태를 의미합니다.

C ABI 기본 조건

• 호출 규약(Call Convention): 함수는 C 호출 규약을 따라야 합니다.
  
• 데이터 표현(Representation): 전달되는 타입은 크기, 정렬, 필드 순서, 패딩이 C와 동일해야 합니다.
  
• 심볼 이름(Name Mangling): 내보내는 심볼은 C와 동일한 이름으로 유지해야 합니다.
  
• 스택 언와인딩(Unwinding): 예외나 패닉은 언어 경계를 넘어가면 안 됩니다.
  
• 정수/포인터 폭: 플랫폼 ABI(LP64, ILP32 등)에 맞춰야 합니다.
  

Ada: Zero-Overhead C 바인딩

함수 Import/Export

with Interfaces.C;

procedure Foo (X : Interfaces.C.int);
pragma Import (C, Foo, "foo");

function Bar (A, B : Interfaces.C.int) return Interfaces.C.int;
pragma Export (C, Bar, "bar");

• pragma Import/Export (C, ...)를 사용하면 Ada 함수가 C ABI와 동일하게 호출됩니다.

구조체 레이아웃

type C_Context is record
   Dummy : Interfaces.C.int;
end record;
pragma Convention (C, C_Context);

• pragma Convention (C, ...)로 구조체 레이아웃을 C와 동일하게 강제합니다.
  
• 필요 시 for ... use record 표현절로 필드 오프셋을 명시할 수 있습니다.

비트마스크/집합 타입

type Event_Condition is (Input, Output, Hang_Up, Error);
for Event_Condition'Size use 8;

type Event_Conditions is set of Event_Condition;
for Event_Conditions'Size use 32;
pragma Convention (C, Event_Conditions);

• Event_Conditions는 32비트로 강제되며, C의 uint32_t와 동일한 ABI를 가집니다.

콜백 (함수 포인터)

type Event_Callback is access procedure
  (FD        : Interfaces.C.int;
   Events    : Event_Conditions;
   User_Data : System.Address)
with Convention => C;

• Convention => C를 붙이면 Ada의 access procedure가 C 함수 포인터와 ABI 일치합니다.

Rust: Zero-Overhead C 바인딩

함수 Import/Export

extern "C" {
    fn foo(x: i32);
}

#[no_mangle]
pub extern "C" fn bar(a: i32, b: i32) -> i32 {
    a + b
}

• extern "C"로 호출 규약을 C와 동일하게 설정합니다.
  
• #[no_mangle]로 심볼 이름을 그대로 유지합니다.

구조체 레이아웃

#[repr(C)]
pub struct CContext {
    pub dummy: i32,
}

• #[repr(C)]로 구조체 레이아웃을 C와 동일하게 강제합니다.

비트마스크

bitflags::bitflags! {
    #[repr(C)]
    pub struct EventMask: u32 {
        const INPUT   = 0x01;
        const OUTPUT  = 0x02;
        const HANG_UP = 0x04;
        const ERROR   = 0x08;
    }
}

• 내부적으로 u32이므로 C의 uint32_t와 동일합니다.

콜백 (함수 포인터)

pub type EventCallback =
    extern "C" fn(fd: i32, events: u32, user_data: *mut core::ffi::c_void);

extern "C" {
    fn 레지스터_cb(cb: EventCallback);
}

• extern "C" fn은 C 함수 포인터와 ABI가 동일합니다.

데이터 타입 일치 조건

• 정수: Ada는 Interfaces.C.*, Rust는 i32, u32 등 고정 폭 타입 사용.
  
• 포인터: Ada는 System.Address, Rust는 *mut T / *const T.
  
• 구조체: Ada pragma Convention (C), Rust #[repr(C)].
  
• 열거형: Ada는 for Enum'Size use ..., Rust는 #[repr(u32)].
  
• 집합/비트마스크: Ada는 for Set'Size use 32, Rust는 u32.

예외 처리 및 안전성

• Ada 예외와 Rust 패닉은 C로 넘어가면 안 됩니다.
  
• Ada에서는 예외를 잡아 에러 코드로 변환, Rust에서는 catch_unwind 사용.
  
• 메모리 관리와 버퍼는 언어 경계에서 직접 전달하며, 소유권은 한쪽 언어에서만 책임집니다.

검증 방법

• 크기/정렬 확인: Ada Type'Size, Rust std::mem::size_of::<T>().
  
• 심볼 확인: nm, objdump, readelf로 확인.
  
• 성능 검증: 마이크로벤치마크로 변환/복사 코드가 없는지 확인.
  

요약

Ada와 Rust 모두 다음 조건을 만족하면 C와 오버헤드 없는 바인딩을 구현할 수 있습니다:

• C 호출 규약(pragma Import/Export (C) / extern "C")
  
• C 호환 레이아웃(pragma Convention (C) / #[repr(C)])
  
• 고정 폭 정수 및 포인터 타입 사용
  
• 예외/패닉 언와인딩 금지
  
• 심볼 이름 unmangled 유지
  

이렇게 하면 Ada와 Rust에서 작성한 코드가 C와 동일한 ABI를 가지며, 변환 계층 없이 직접 호출 가능합니다.

주의:

LLM으로 작성한 글입니다. 글에 틀린 내용이 있을 수 있습니다.

제가 아직 Ada, Rust 관련 글의 내용을 검증할 수준이 못됩니다.