HN 日本語サマリー

← 一覧へ戻る
プログラミング

C++ ABIを徹底的に理解する

Thoroughly Understanding C++ ABI (ykiko.me)

54 pointsby rramadass59 コメント

要約

この記事は、C++のアプリケーションバイナリインターフェース(ABI)について、CPUとOSの互換性、オブジェクトファイルフォーマット、データ表現、関数呼び出し規約といった側面から詳細に解説しています。ABIの安定性がプログラムの互換性にいかに重要であるかを、具体的な例を交えながら説明しています。

全文翻訳

C++ ABI を徹底的に理解する

この記事は、Gemini 2.5 Pro を使用してAIによって元の中国語版から翻訳されました。軽微な不正確さが残っている可能性があります。

アプリケーションバイナリインターフェース、通称ABIは、馴染み深くもあり、そうでもない概念です。馴染み深いとはどういう意味でしょうか? トラブルシューティングの際にしばしば話題に上り、記事で頻繁に言及され、時にはそれが引き起こす互換性の問題に対処しなければならないこともあります。そうでもないとはどういう意味でしょうか? もし誰かにABIとは何かと尋ねられたら、それが何についてのものかは知っているものの、正確な言葉で説明するのが非常に難しいことに気づくでしょう。結局、WIKI が言うように、「ABIは2つのバイナリプログラムモジュール間のインターフェースである」とだけ言うことになるかもしれません。それに問題があるでしょうか? いいえ、一般的な説明としては十分です。しかし、少し空虚に感じられるかもしれません。

このような状況は、コンピュータサイエンスの分野では珍しくありません。著者は、以前の記事でリフレクションについて議論した際にも、全く同じ状況に遭遇しました。根本的に、CSは絶対的な厳密さを追求する学問ではなく、多くの概念には厳密な定義がなく、むしろ慣習的な理解であることが多いのです。したがって、定義にこだわりすぎるのではなく、これらのいわゆるバイナリインターフェースが実際には何であり、その安定性にどのような要因が影響を与えるのかを見ていきましょう。

CPU & OS

最終的な実行可能ファイルは、最終的には特定のCPU上の特定のオペレーティングシステムで実行されます。CPUの命令セットが異なれば、間違いなくバイナリの非互換性につながります。例えば、ARM 上のプログラムは、x64プロセッサ上では(仮想化技術が使用されない限り)直接実行できません。命令セットが互換性がある場合はどうでしょうか? 例えば、x64プロセッサはx86命令セットと互換性があります。それは、x86プログラムがx64オペレーティングシステム上で確実に実行できることを意味するでしょうか? ここでオペレーティングシステムが関わってきます。具体的には、オブジェクトファイル形式、データ表現、関数呼び出し規約、そしてランタイムライブラリといった要因を考慮する必要があります。これらの点は、オペレーティングシステムレベルでのABI規則と見なすことができます。4番目の点については、後で専用のセクションで議論します。以下では、x64プラットフォームを例に、最初の3つの点について議論します。

x64、x86-64、x86_64、AMD64、Intel 64はすべて、x86命令セットの64ビットバージョンを指します。

x64プラットフォームには、主に2つの一般的なABIがあります:

  • 64ビットWindowsオペレーティングシステム用のWindows x64 ABI
  • 64ビットLinuxおよびさまざまなUNIXライクオペレーティングシステム用のx86-64 System V ABI

ダイナミックライブラリから関数を呼び出すことは、単純に以下の3つのステップとして見ることができます:

  • 特定の形式に従ってダイナミックライブラリを解析する。
  • 解析結果からシンボル名に基づいて関数のアドレスを検索する。
  • 関数パラメータを渡し、関数を呼び出す。
オブジェクトファイル形式

ダイナミックライブラリをどのように解析するのでしょうか? ここでABIのオブジェクトファイル形式に関する規則が関わってきます。独自のリンカを書きたい場合、最終的な実行可能ファイルは対応するプラットフォームの形式要件を満たす必要があります。Windows x64はPE32+実行可能ファイル形式を使用します。これはPE32(Portable Executable 32-bit)の64ビットバージョンです。System V ABIはELF(Executable Linkable Format)実行可能ファイル形式を使用します。pe-parseやelfioのような解析ライブラリ(または興味があれば自分で書く)を使用して実際の実行可能ファイルを解析し、シンボルテーブルを取得することで、関数名と関数アドレスのマッピングを得ることができます。

データ表現

関数のアドレスを取得した後、次のステップはどのように呼び出すかです。呼び出す前に、パラメータを渡す必要がありますよね? パラメータを渡す際には、データ表現の一貫性に特別な注意を払う必要があります。これはどういう意味でしょうか?

以下のファイルをダイナミックライブラリにコンパイルしたと仮定します:

struct X{
    int a;
    int b;
};

int foo(X x){
    return x.a + x.b;
}

その後、後続のバージョンアップで構造体の内容が変更され、ユーザーのコードで見られる構造体の定義が以下のようになるとします:

struct X{
    int a;
    int b;
    int c;
};

そして、古いバージョンのコードからコンパイルされたダイナミックライブラリにリンクしてその関数を呼び出そうとします:

int main(){
    int n = foo({1, 2, 3});
    printf("%d\n", n);
}

成功するでしょうか? もちろん失敗します。この種のエラーは、いわゆるODR(One Definition Rule)違反と見なすことができます。後続のセクションでさらに例を議論します。

上記の状況は、ユーザーが意図的にコードを変更したことによって引き起こされるODR違反です。しかし、意図的にコードを変更しない場合、構造体のレイアウトの安定性を保証できるでしょうか? これはABIのデータ表現によって保証されます。例えば、基本型のサイズとアラインメントを指定します。Windows x64はlongを32ビットと指定しますが、System Vはlongを64ビットと指定します。また、structやunionのサイズとアラインメントなども指定します。

C言語の標準は依然としてABIを指定していないことに注意してください。System V ABIは主にC言語の用語と概念を使用して書かれているため、C言語のABIを提供していると見なすことができます。Windows x64 ABIは、CとC++の間に明確な境界線を持っていません。

関数呼び出し規約

次に、関数パラメータを渡すステップに進みます。関数は単なるバイナリデータの一部であることを知っています。関数を実行することは、単に関数のエントリポイントアドレスにジャンプし、そのコードを実行し、終了したらジャンプして戻ることです。パラメータ渡しは、データを格納する場所を見つけることに他なりません、この場所から呼び出しの前後にデータを取得できるようにするためです。どのような場所が選択できるでしょうか? 主に4つの選択肢があります:

  • グローバル(グローバル変数)
  • ヒープ(ヒープ)
  • レジスタ(レジスタ)
  • スタック(スタック)

パラメータ渡しにグローバル変数を使用するのは魔法のように聞こえますが、実際には、コードを書く際に、configのように繰り返し渡す必要があるパラメータはグローバル変数に変更されることがよくあります。しかし、すべてのパラメータがグローバル変数渡しに適しているわけではなく、スレッドセーフティをさらに慎重に考慮する必要があることは明らかです。

ヒープをパラメータ渡しに使用するのも信じられないように思えますが、実際には、C++20のスタックレスコルーチンはコルーチン状態(関数パラメータ、ローカル変数)をヒープに格納します。しかし、通常の関数呼び出しでは、パラメータを渡すたびに動的メモリ割り当てが必要な場合、それは確かに少し贅沢です。

したがって、主にレジスタとスタックを使用してパラメータを渡すことを検討します。選択肢が多いのは常に良いことですが、ここではそうではありません。呼び出し側がパラメータをレジスタ経由で渡すべきだと考えている場合、パラメータをレジスタに格納します。しかし、呼び出し先はパラメータをスタック経由で渡すべきだと考えているため、スタックからデータを取得します。不一致が生じ、スタックからガベージ値を読み取る可能性が非常に高く、コードに論理エラーが発生したり、プログラムがクラッシュしたりします。

呼び出し側と呼び出し先が同じ場所にパラメータを渡すことをどのように保証するのでしょうか? これが関数呼び出し規約が登場する場面だと、すでに推測されていることでしょう。

具体的には、呼び出し規約は以下を指定します:

  • 関数パラメータの渡し順序:左から右か、右から左か?
  • 関数パラメータと戻り値の渡し方法:スタック経由か、レジスタ経由か?
  • 呼び出し側が呼び出しの前後に変更してはならないレジスタはどれか?
  • スタックフレームのクリーンアップを担当するのは誰か:呼び出し側か、呼び出し先か?
  • C言語の可変長引数関数をどのように処理するか?
  • ...

32ビットプログラムでは、__cdecl、__stdcall、__fastcall、__thiscallなど、多くの呼び出し規約があり、当時のプログラムは互換性の問題に大きく悩まされていました。64ビットプログラムでは、統一がほぼ達成されています。主に2つの呼び出し規約があり、それぞれWindows x64 ABIとx86-64 System V ABIによって指定されています(正式な名前はありませんが)。関数パラメータの渡し方法は、呼び出し規約にのみ関連し、コード最適化レベルとは無関係であることを強調する必要があります。異なる最適化レベルでコンパイルされたコードがリンク時に失敗することを望まないでしょう?

具体的な規則を導入するのは面倒です。興味のある読者は、対応するドキュメントの関連セクションを参照してください。以下では、より興味深いトピックを中心に議論します。

注意:以下の議論は、関数呼び出しが発生する場合にのみ適用されます。関数が完全にインライン化された場合、関数パラメータを渡すという行為は発生しません。現在、C++コードのインライン化最適化は、主に同じコンパイル単位(単一ファイル)内で行われます。コンパイル単位をまたぐコードの場合、LTO(Link Time Optimization)を有効にする必要があります。ダイナミックライブラリをまたぐコードは、まだインライン化できません。

  • 16バイト未満の構造体値を値で渡すことは、参照で渡すよりも効率的です。

この声明は長い間存在していましたが、その根拠を見つけたことはありませんでした。最近、呼び出し規約を調査中に、その理由を見つけました。まず、構造体のサイズが8バイト以下の場合、パラメータ渡しのために64ビットレジスタに直接配置できます。レジスタ経由でパラメータを渡すことは、参照で渡すよりもメモリアクセスが少なく、より効率的です。これは問題ありません。16バイトの場合はどうでしょうか? System V ABIでは、16バイトの構造体を2つの8バイトの部分に分割し、レジスタを個別に使って渡すことができます。この場合、値渡しは参照渡しよりも確かに効率的です。以下のコードを観察してください:

#include <cstdio>

struct X {
    size_t x;
    size_t y;
};

extern void f(X);
extern void g(const X&);

int main() {
    f({1, 2}); // 値渡し
    g({1, 2}); // 参照渡し
}

生成されるコードは以下のようになります:

main:
        sub     rsp, 24
        mov     edi, 1
        mov     esi, 2
        call    f(X)
        movdqa  xmm0, XMMWORD PTR .LC0[rip]
        mov     rdi, rsp
        movaps  XMMWORD PTR [rsp], xmm0
        call    g(X const&)
        xor     eax, eax
        add     rsp, 24
        ret
.LC0:
        .quad   1
        .quad   2

System V ABIは、最初の6つの整数パラメータをそれぞれrdi、rsi、rdx、rcx、r8、r9レジスタで渡すことができると指定しています。Windows x64 ABIは、最初の4つの整数パラメータをそれぞれrcx、rdx、r8、r9レジスタで渡すことができると指定しています。レジスタが不足した場合、パラメータはスタック経由で渡されます。整数パラメータには、char、short、int、long、long long、その他の基本的な整数型、およびポインタ型が含まれます。浮動小数点パラメータとSIMD型パラメータには専用のレジスタがありますが、ここでは詳細を説明しません。

1と2がそれぞれレジスタediとesiを介して関数fに渡されているのに対し、gには一時変数のアドレスが渡されていることがわかります。ただし、これはSystem V ABIの場合のみです。Windows x64 ABIの場合、構造体のサイズが8バイトを超える場合、参照でしか渡せません。 同じコードをWindowsでコンパイルすると、次の結果が得られます:

main:
        sub     rsp, 56
        lea     rcx, QWORD PTR [rsp+32]
        mov     QWORD PTR [rsp+32], 1
        mov     QWORD PTR [rsp+40], 2
        call    void f(X)
        lea     rcx, QWORD PTR [rsp+32]
        mov     QWORD PTR [rsp+32], 1
        mov     QWORD PTR [rsp+40], 2
        call    void g(X const &)
        xor     eax, eax
        add     rsp, 56
        ret     0

両方の関数呼び出しで生成されるコードが全く同じであることがわかります。これは、Windows x64 ABIでは、8バイトを超える構造体が参照で渡されるか値で渡されるかに関わらず、生成されるコードは同一であることを意味します。

  • unique_ptrとraw_ptrは全く同じ効率です。

さて、これまではこのことを固く信じていました。結局、unique_ptrは生のポインタの単純なラッパーに過ぎません。しかし、示唆に富むCPPCONの講演「コストゼロの抽象化は存在しない」を見るまで、完全に思い込みだったことに気づきませんでした。ここでは、例外による追加のオーバーヘッド(デストラクタがスタックフレームのクリーンアップのためにコンパイラに追加コードを生成する必要があること)については議論しません。C++オブジェクト(8バイト未満)をレジスタ経由で渡せるかどうかだけを議論しましょう。完全にトリビアルな型の場合、問題ありません。C言語の構造体とほぼ同じように動作します。しかし、トリビアルでない場合はどうでしょうか?

例えば、カスタムコピーコンストラクタが定義されている場合、レジスタに配置できるでしょうか? 論理的にはできません。なぜでしょうか? C++では関数パラメータのアドレスを取得できることを知っています。整数パラメータがレジスタ経由で渡された場合、そのアドレスを取得した結果はどこから来るのでしょうか? 実験してみましょう:

#include <cstdio>

extern void f(int&);

int g(int x) {
    f(x);
    return x;
}

対応するアセンブリコードは以下のようになります:

g(int):
        sub     rsp, 24
        mov     DWORD PTR [rsp+12], edi
        lea     rdi, [rsp+12]
        call    f(int&)
        mov     eax, DWORD PTR [rsp+12]
        add     rsp, 24
        ret

edi(最初の整数パラメータを渡すために使用)の値がスタック上のアドレスrsp+12にコピーされ、そのアドレスがfに渡されていることがわかります。これは、関数パラメータがレジスタ経由で渡され、そのアドレスが何らかの状況で必要とされる場合、コンパイラはそのパラメータをスタックにコピーすることを意味します。しかし、ユーザーはこれらのコピープロセスを観察できません。なぜなら、コピーコンストラクタはトリビアルだからです。最終的なコードの実行結果に影響を与えない最適化は、as-ifルールに準拠しています。

ここで、このオブジェクトにユーザー定義のコピーコンストラクタがある場合、パラメータがレジスタ経由で渡されていると仮定すると、追加のコピーコンストラクタ呼び出しが発生する可能性があり、ユーザーはこの副作用を観察できます。これは明らかに不合理なので、ユーザー定義のコピーコンストラクタを持つオブジェクトはレジスタ経由で渡すことができません。スタック経由で渡す場合はどうでしょうか? 実際には、同様のコピーのジレンマに遭遇するでしょう。したがって、そのようなオブジェクトは最終的に参照でしか渡せません。コピーコンストラクタを明示的にdeleteとマークすることも、ユーザー定義のコピーコンストラクタと見なされることに注意してください。

したがって、unique_ptrの場合、参照でしか渡せません。関数のシグネチャをvoid f(unique_ptr<int>)またはvoid f(unique_ptr<int>&)と記述したとしても、パラメータ渡し時点でのバイナリコードは同じになります。しかし、生のポインタはレジスタ経由で安全に渡すことができます。結論として、unique_ptrと生のポインタの効率は全く同じではありません。

実際には、非トリビアルなC++オブジェクトがレジスタ経由で渡せるかどうかの実際の状況は、より複雑です。関連する詳細は、それぞれのABIの対応するセクションで見つけることができ、ここでは詳細を説明しません。さらに、C++オブジェクトの渡し方に関する規則がオペレーティングシステムのABIに属するのか、C++コンパイラのABIに属するのかは完全には明らかではありません。

C++ 標準

最後に、オペレーティングシステムレベルでの保証について説明しました。低レベルに偏っており、多くの実際のアセンブリコードが含まれているため、アセンブリにあまり慣れていない読者には難しいかもしれません。しかし、以下の内容は基本的にアセンブリとは無関係なので、自信を持って読み進めてください。

C++標準はABIを明示的に指定していませんが、全く規則がないわけではありません。コンパイラ実装にはいくつかの要件があります。例えば:

  • 構造体メンバーのアドレスは、宣言順に増加します(説明)。これは、コンパイラが構造体メンバーを並べ替えないことを保証します。
  • 標準レイアウト制約を満たす構造体は、対応するC構造体とレイアウト互換性がある必要があります。
  • トリビアルにコピー可能制約を満たす構造体は、memmoveまたはmemcpyを使用してコピーすることで、同一の新しいオブジェクトを取得できます。
  • ...

さらに、C++が新しいバージョンをリリースし続けるにつれて、同じコードを新しい標準と古い標準でそれぞれコンパイルした場合、結果は同じになるでしょうか(条件付きコンパイルのためにマクロを使用してC++バージョンを制御する影響は除く)? これはC++標準のABI互換性に関する保証にかかっています。実際には、C++標準は後方互換性を確保しようとします。つまり、2つのコード片について、古い標準と新しい標準でコンパイルされたコードは完全に同じであるべきです。

しかし、例外は非常に少ないです(著者はこれらしか見つけられませんでした。コメントで自由に追記してください):

  • C++17はnoexceptを関数型のの一部とし、関数の生成されるマングリング名に影響を与えます。
  • C++20はno_unique_addressを導入しましたが、MSVCはABIのブレークを引き起こすため、まだ直接サポートしていません。

新しいC++バージョンは、古いコードに影響を与えることなく、新しい言語機能と新しいABIを導入することがよくあります。例えば、C++23で追加された2つの新機能です:

明示的なオブジェクトパラメータ

C++23より前は、メンバ関数のアドレスを取得する合法的な方法はありませんでした。できることはメンバポインタを取得することだけでした(メンバポインタとは何かについては、この記事を参照してください):

struct X {
    void f(int);
};

auto p = &X::f;
// p は X のメンバ関数へのポインタです
// p の型は void (X::*)(int) です

メンバ関数をコールバックとして使用するには、ラムダ式でラップするしかありませんでした:

struct X {
    void f(int);
};

using Fn = void(*)(X*, int);
Fn p = [](A* self, int x) { self->f(x); };

これは実際にはかなり煩雑で不要であり、このラッパー層は追加の関数呼び出しオーバーヘッドを引き起こす可能性があります。ある程度、これは歴史的な問題です。32ビットシステムでは、メンバ関数の呼び出し規約はやや特殊でした(有名なthiscall)、そしてC++には呼び出し規約に関する内容はなかったため、メンバ関数ポインタが作成されました。ABI互換性のために古いコードを変更することはできませんが、新しいコードは変更できます。C++23は明示的なオブジェクトパラメータを追加したため、thisがどのように渡されるかを明確に定義できるようになり、値渡しさえ使用できるようになりました:

struct X {
    // 'this' は古い構文と区別するためのマーカーです
    void f(this X self, int x); // 値渡し
    void g(this X& self, int x); // 参照渡し
};

明示的なthisでマークされた関数は、通常の関数のように、その関数アドレスを直接取得することもできます:

auto f = &X::f; // f の型は void(*)(X, int) です
auto g = &X::g; // g の型は void(*)(X*, int) です

したがって、新しいコードはこの記述スタイルを採用でき、メリットのみがあり、欠点はありません。

静的 operator()

標準ライブラリの一部の関数オブジェクトは、operator()以外のメンバを持っていません。例えばstd::hashです:

template <class T>
struct hash {
    std::size_t operator()(T const& t) const;
};

これは空の構造体ですが、operator()はメンバ関数であるため、暗黙のthisパラメータを持っています。非インライン呼び出しの場合、無用なヌルポインタを渡す必要があります。C++23でこの問題は解決され、static operator()を直接定義してこの問題を回避できるようになりました:

template <class T>
struct hash {
    static std::size_t operator()(T const& t);
};

staticはこれが静的関数であることを意味し、その使用法は以前と同じです:

std::hash<int> h;
std::size_t n = h(42);

ただし、hashは単なる例です。実際には、標準ライブラリコードはABI互換性のために変更されません。新しいコードはこの機能を使用して、不要なthis渡しを回避できます。

コンパイラ固有

さて、本題に入ります。実装定義の部分です。このセクションは最も批判される内容のようですが、本当にそうでしょうか? 一つずつ見ていきましょう。

事実上の標準

C++のいくつかの抽象化は、最終的に実装される必要があり、標準が実装方法を指定していない場合、この部分はコンパイラの裁量に委ねられます。例えば:

  • 名前マングリング規則(関数オーバーロードやテンプレート関数の実装のため)
  • 複雑な型のレイアウト(例:仮想継承を持つもの)
  • 仮想関数テーブルのレイアウト
  • RTTIの実装
  • 例外処理
  • ...

コンパイラがこれらの部分を異なる方法で実装すると、異なるコンパイラでコンパイルされたバイナリ製品は当然互換性がなく、混合できません。

1990年代はC++開発の黄金期であり、様々なベンダーが独自のコンパイラの実装とユーザーベースの拡大に専念し、ユーザーを競い合っていました。この競争のため、異なるコンパイラが異なるABIを使用することは一般的でした。時間が経過するにつれて、それらのほとんどは歴史の舞台から姿を消しました。更新を停止したり、既存のバージョンのみを維持したり、新しいC++標準に追従しなくなったりしました。この波の後、GCC、Clang、MSVCだけが3つの主要なコンパイラとして残りました。

今日、C++コンパイラのABIはほぼ統一されており、主に2つのABIしかありません:

  • 公開されているドキュメントを持つItanium C++ ABI
  • 公式ドキュメントはありませんが、非公式のバージョンが入手可能なMSVC C++ ABI

Itanium C++ ABIという名前ですが、実際にはクロスアーキテクチャのC++用ABIです。MSVCを除くほぼすべてのC++コンパイラがこれを使用していますが、例外処理の詳細にはわずかな違いがあります。歴史的に、C++コンパイラは独自のC++ ABIを扱っていました。IntelがItaniumを強く推進していたとき、互換性の問題を避けたいと考え、Itanium上のすべてのC++ベンダーのために標準化されたABIを作成しました。その後、様々な理由で、GCCは内部ABIを変更する必要があり、Itanium ABIをすでにサポートしていた(Itaniumプロセッサ用)ことを考慮して、独自のABIを作成するのではなく、ABI定義をすべてのアーキテクチャに拡張することを選択しました。それ以来、MSVCを除くすべての主要コンパイラがクロスアーキテクチャのItanium ABIを採用し、Itaniumプロセッサ自体はメンテナンスされなくなりましたが、ABIは依然として維持されています。

Linuxプラットフォームでは、GCCとClangの両方がItanium ABIを使用しているため、これらの2つのコンパイラでコンパイルされたコードは相互運用可能であり、リンクして実行できます。Windowsプラットフォームでは、状況は少し複雑です。デフォルトのMSVCツールチェーンは独自のABIを使用します。しかし、MSVCツールチェーンに加えて、GCCもWindowsに移植されており、MinGWツールチェーンとして知られており、依然としてItanium ABIを使用しています。これらの2つのABIは互換性がなく、それらでコンパイルされたコードは直接リンクできません。Windows上のClangは、コンパイルオプションを通じてこれらの2つのABIのどちらを使用するかを制御できます。

注意:MinGWはWindows上で実行されるため、生成されるコードの呼び出し規約は自然にWindows x64 ABIに準拠しようとし、最終的な実行可能ファイル形式もPE32+です。しかし、それが使用するC++ ABIは依然としてItanium ABIであり、両者の間には必然的な関係はありません。

巨大なC++コードベースを考慮すると、これらの2つのC++ ABIはほぼ安定しており、さらに変更されることはありません。したがって、C++コンパイラには安定したABIがあると言えます。 いかがでしたか? オンラインの主流の見解とは異なりますか? しかし、事実はまさにここにあります。

MSVCは、2015年以降、ABIの安定性を保証しています。GCCは3.4からItanium ABIを使用し、それ以来ABIの安定性を保証しています。

回避策

基本的なABIは変更されなくなりましたが、コンパイラバージョンをアップグレードすると、コンパイルされたライブラリでABIのブレークが発生する可能性があります。なぜでしょうか?

これは理解するのが難しくありません。まず、コンパイラもソフトウェアであり、すべてのソフトウェアにはバグが存在する可能性があります。時には、バグを修正するために、ABIのブレークが強制されることがあります(通常、新バージョンのリリースノートで詳細に説明されています)。例えば、GCCにはこれらの異なるバージョンを制御するためのコンパイルオプション-fabi-versionがあります。その内容の一部は以下の通りです:

  • バージョン7はG++ 4.8に初めて登場し、nullptr_tを組み込み型として扱い、デフォルト引数スコープでのラムダ式の名前エンコーディングを修正しました。
  • バージョン8はG++ 4.9に初めて登場し、関数CV修飾子を持つ関数型の置換動作を修正しました。
  • バージョン9はG++ 5.2に初めて登場し、nullptr_tのアライメントを修正しました。

さらに、ユーザーがコンパイラバグを回避するために特別なコードを書いている可能性があり、これは一般的に回避策と呼ばれます。バグが修正されると、これらの回避策は悪影響を及ぼし、ABIの非互換性を引き起こす可能性があります。

重要なオプション

さらに、コンパイラは動作を制御するための多くのオプションを提供しており、これらのオプションはABIに影響を与える可能性があります。例えば:

  • -fno-strict-aliasing: 厳密なエイリアシングを無効にする
  • -fno-exceptions: 例外を無効にする
  • -fno-rtti: RTTIを無効にする
  • ...

異なるオプションでコンパイルされたライブラリをリンクする場合、互換性の問題には特に注意が必要です。例えば、コードで厳密なエイリアシングを無効にしているが、依存する外部ライブラリが厳密なエイリアシングを有効にしている場合、ポインタ伝播エラーが発生する可能性が非常に高く、プログラムエラーにつながります。

著者は最近この状況に遭遇しました。Pythonのラッパーをpybind11を使用していくつかのLLVM関数用に書いていました。Pybind11はRTTIを有効にする必要がありますが、LLVMのデフォルトビルドは例外とRTTIを無効にしていたため、コードをリンクできませんでした。当初、RTTIを有効にしたLLVMバージョンをコンパイルしましたが、バイナリが肥大化しました。後に、これは不要であることに気づきました。LLVM型に対してRTTI情報を使用していたわけではなく、単に同じファイルに記述されていたため、コンパイラが使用していると思っただけでした。そこで、コードのLLVM依存部分を別のダイナミックライブラリにコンパイルし、それをpybind11依存部分とリンクすることで解決しました。

ランタイム & ライブラリ

このサブセクションでは、主にC++プログラムが依存するライブラリのABI安定性について議論します。理想的には、実行可能プログラムの場合、古いバージョンのダイナミックライブラリを新しいバージョンに置き換えても、その動作に影響を与えないはずです。

3つの主要なC++コンパイラは、それぞれ独自の標準ライブラリを持っています:

前述したように、C++標準はABIの後方互換性を確保しようとします。C++98からC++11へのメジャーアップデートでも、古いコードのABIは大きく影響されず、ABIブレーク変更に関する記述は全くありませんでした。

しかし、C++標準ライブラリに関しては、状況は少し異なります。C++98からC++11にかけて、標準ライブラリはメジャーなABIブレーク変更を受けました。標準ライブラリは、std::stringなどの一部のコンテナ実装に対する要件を変更しました。これにより、広く使用されていたCOW(Copy-On-Write)実装が新しい標準に準拠しなくなり、C++11では新しい実装を採用する必要が生じました。これが、C++98とC++11標準ライブラリ間のABIブレークの原因となりました。しかし、それ以降、標準ライブラリのABIは一般的に比較的安定しており、各実装はこの安定性を確保しようとしています。詳細については、stl、libstdc++、およびlibc++の関連ページを参照してください。

さらに、RTTIと例外は一般的にオフにできるため、これらの2つの機能は、MSVCのvcruntimeやlibc++のlibcxxabiのような個別のランタイムライブラリによって処理される可能性があります。

libcxxabiは、静的ローカル変数の初期化サポートも含まれていることに言及する価値があります。これは主に__cxa_guard_acquireと__cxa_guard_release関数に関連しており、静的ローカル変数が実行時に一度だけ初期化されることを保証するために使用されます。具体的な実装に興味がある場合は、関連するソースコードを参照できます。

libgccやcompiler-rtのような低レベル関数を担当するランタイムライブラリもあります。

標準ライブラリに加えて、C++プログラムは一般的にCランタイムにもリンクする必要があります:

  • Windowsでは、CRTをリンクする必要があります。
  • Linuxでは、使用するディストリビューションとコンパイル環境に応じて、glibcまたはmuslにリンクする場合があります。

Cランタイムは、C標準ライブラリの実装を提供するだけでなく、プログラムの初期化とクリーンアップも担当します。main関数の呼び出しや、プログラムの起動および終了プロセスの管理、必要な初期化およびクリーンアップタスクの実行を担当します。オペレーティングシステムで実行されるほとんどのソフトウェアにとって、それにリンクすることは不可欠です。

理想的な状態は、コンパイラをアップグレードする際に、これらの対応するランタイムライブラリのバージョンもアップグレードして、不要なトラブルを避けることです。しかし、実際のプロジェクトでは、依存関係は非常に複雑になり、連鎖反応を引き起こす可能性があります。

ユーザーコード

最後に、ユーザーコード自体の変更によって引き起こされるABIの問題について話しましょう。ライブラリをバイナリ形式で配布したい場合、ユーザーベースが一定の規模に達すると、ABI互換性が非常に重要になります。

呼び出し規約を議論した最初のサブセクションで、構造体定義の変更によって引き起こされるABIの非互換性について言及しました。では、将来の拡張の余地を残しつつABI互換性を確保したい場合はどうでしょうか? 答えは、実行時に処理することです:

struct X{
    size_t x;
    size_t y;
    void* reserved;
};

void*ポインタを使用して、将来の拡張のためのスペースを予約します。それに基づいて、異なるバージョンを区別できます。例えば:

void f(X* x) {
    Reserved* r = static_cast<Reserved*>(x->reserved);
    if (r->version == ...) {
        // 何かを行う
    } else if (r->version == ...) {
        // 別の何かを行う
    }
}

このように、既存のコードに影響を与えることなく、新機能を追加できます。

インターフェースを公開する際には、関数パラメータにカスタムデストラクタを持つ型に特別な注意を払う必要があります。例えば、std::vectorを戻り値として公開したいとします。例えば、以下の簡単なコードをダイナミックライブラリにコンパイルし、 MTオプションを使用してWindows CRTを静的にリンクします。

__declspec(dllexport) std::vector<int> f() {
    return {1, 2, 3};
}

次にソースファイルを作成し、コンパイルしたばかりのダイナミックライブラリにリンクして、この関数を呼び出します:

#include <vector>

std::vector<int> f();

int main() {
    auto vec = f();
}

コンパイルして実行すると、直接クラッシュします。ダイナミックライブラリを MTを無効にして再コンパイルしてから実行すると、すべて正常に動作します。奇妙なことに、依存するダイナミックライブラリがCRTを静的にリンクするとコードがクラッシュするのでしょうか?

上記のコードを考えると、vecの構築は実際にはダイナミックライブラリ内で行われ、その破棄はmain関数内で行われることがわかります。より正確には、メモリはダイナミックライブラリ内で割り当てられ、main関数内で解放されます。しかし、各CRTは独自のmallocとfreeを持っています(異なるプロセス間のメモリと同様)。CRT Aで割り当てられたメモリをCRT Bで解放することはできません。 これが問題の根本原因です。したがって、CRTを静的にリンクしなかった後、すべて正常に動作します。それらはすべて同じmallocとfreeを使用します。これはWindows CRTだけでなく、Linuxのglibcやmuslにも適用されます。例のコードはこちらで入手できます。自由に試してみてください。

extern "C"

上記のような状況は、カスタムデストラクタを持つ任意のC++型で発生する可能性があります。様々な理由により、コンストラクタとデストラクタの呼び出しがダイナミックライブラリの境界を越えると、RAII契約が破られ、深刻なエラーにつながります。

これを解決するにはどうすればよいでしょうか? 当然ながら、関数パラメータと戻り値はデストラクタを持つ型ではなく、POD型のみを使用すべきです。

例えば、上記の例は次のように変更する必要があります:

using Vec = void*;

__declspec(dllexport) Vec create_Vec() {
    return new std::vector<int>;
}

__declspec(dllexport) void destroy_Vec(Vec vec) {
    delete static_cast<std::vector<int>*>(vec);
}

そして、使用法は次のようになります:

using Vec = void*;

Vec create_Vec();
void destroy_Vec(Vec vec);

int main() {
    Vec vec = create_Vec();
    destroy_Vec(vec);
}

実際には、CスタイルのRAIIのようにカプセル化しています。さらに、マングリングの違いによるCとC++間のリンク問題を解決したい場合は、extern "C"を使用して関数を装飾できます:

extern "C" {
    Vec create_Vec();
    void destroy_Vec(Vec vec);
}

これにより、C言語も上記のエクスポートされた関数を使用できます。

しかし、コードベースが大きい場合、すべての関数をこのようなAPIにカプセル化するのは明らかに現実的ではありません。その場合、C++型をエクスポートされたインターフェースで公開する必要があり、依存関係は慎重に管理する必要があります(例:依存するすべてのライブラリを静的にリンクする)。具体的な選択は、プロジェクトの規模と複雑さによります。

結論

ここで、C++プログラムのABIに影響を与える主な要因について議論しました。C++標準、コンパイラベンダー、ランタイムライブラリがABIの安定性を維持するために努力していることは明らかです。C++ ABIは、多くの人が主張するほど悪くも不安定でもありません。小規模なプロジェクトでは、ソースコードとの静的リンクにより、互換性の問題はほぼすべて排除されます。大規模で長期間稼働しているプロジェクトでは、複雑な依存関係のため、特定のライブラリバージョンのアップグレードがプログラムのクラッシュを引き起こす可能性があります。しかし、これはC++のせいではありません。大規模プロジェクトの管理は、言語レベル自体を超えたものです。プログラミング言語を変更するだけでこれらの問題を解決できると期待することはできません。 実際、ソフトウェアエンジニアリングを学ぶことは、巨大な複雑性に対処する方法と、複雑なシステムの安定性を確保する方法を学ぶことです。

記事はここで終わります。お読みいただきありがとうございました。著者の専門知識は限られており、この記事は幅広いトピックをカバーしています。コメントを残して、誤りがあれば議論してください。

その他の参考資料: