abi.dd

Ddoc

$(SPEC_S アプリケーションバイナリインターフェイス,

	$(P ABI（アプリケーション・バイナリインターフェイス）
	に従ったDの実装は、
	他の実装によって生成されたライブラリや
	DLL
	などと相互利用することが可能なバイナリを出力します。
	)

$(SECTION3 C ABI,

	$(P この仕様で C ABI として参照するのは、対象とするシステムの
	C言語のアプリケーション・バイナリインターフェイスです。
	C と D のコードは制限無くリンクでき、特に、D のコードからは
	C の ABI を持ったランタイムライブラリには完全にアクセス可能となっています。
	)
)

$(SECTION3 エンディアン,

	$(P データレイアウトの $(LINK2 http://en.wikipedia.org/wiki/Endianness, エンディアン)
	(バイトオーダー) は、
	対象マシンのエンディアンに従います。
	Intel x86 CPU では、
	値 0x0A0B0C0D がメモリ上で
	$(CODE 0D 0C 0B 0A) と表現される $(I リトルエンディアン) になります。
	)
)

$(SECTION3 基本型,

	$(TABLE1
	$(TROW bool, 8 bit byte。0 が false、1 が true を表す)
	$(TROW byte, 8 bit signed)
	$(TROW ubyte, 8 bit unsigned)
	$(TROW short, 16 bit signed)
	$(TROW ushort, 16 bit unsigned)
	$(TROW int, 32 bit signed)
	$(TROW uint, 32 bit unsigned)
	$(TROW long, 64 bit signed)
	$(TROW ulong, 64 bit unsigned)
	$(TROW cent, 128 bit signed)
	$(TROW ucent, 128 bit unsigned)
	$(TROW float, 32 bit IEEE 754 浮動小数点数)
	$(TROW double, 64 bit IEEE 754 浮動小数点数)
	$(TROW real, 実装定義の浮動小数点数。
	 x86 では 80 bit IEEE 754 拡張実数)
	)
)

$(SECTION3 delegate,

	$(P delegate は２つの部分から構成される $(I fat pointers) です:)

	$(TABLE2 delegate のレイアウト,
	$(TR $(TH オフセット) $(TH プロパティ) $(TH 内容))
	$(TR $(TD 0) $(TD $(CODE .ptr)) $(TD コンテキストポインタ))
	$(TR $(TD $(I ptrsize)) $(TD $(CODE .funcptr)) $(TD 関数ポインタ))
	)

	$(P $(I コンテキストポインタ) は、クラスの $(I this)
	参照か構造体の $(I this) ポインタ、あるいは
	クロージャ、
	または周囲の関数のスタックフレーム（ネスト関数の場合）へのポインタです。
	)
)

$(SECTION3 構造体,

	$(P 対象環境の C ABI の構造体レイアウトに従います。)
)

$(SECTION3 クラス,

	$(P オブジェクトのメモリ構成は次のようになっています:)

$(TABLE2 クラスオブジェクトのレイアウト,
$(TR $(TH サイズ) $(TH プロパティ) $(TH 内容))
$(TR $(TD $(I ptrsize)) $(TD $(CODE .__vptr)) $(TD vtableへのポインタ))
$(TR $(TD $(I ptrsize)) $(TD $(CODE .__monitor)) $(TD モニタ))
$(TR $(TD ...) $(TD ...) $(TD 基底クラスの非staticメンバとinterfaceのvtableへのポインタ。継承のルートから順に。))
$(TR $(TD ...) $(TD named fields) $(TD 非staticメンバ))
$(TR $(TD $(I ptrsize)...) $(TD  ) $(TD このクラスの実装するinterfaceのvtableへのポインタ。左から右、直近の派生元から遠くの派生元、の順で。))
)

	$(P vtableの構成は次の通り：)

$(TABLE2 仮想関数ポインタテーブルのレイアウト,
$(TR $(TH サイズ)		$(TH 内容))
$(TR $(TD $(I ptrsize)) $(TD $(V1 ClassInfo)$(V2 TypeInfo) のインスタンスへのポインタ))
$(TR $(TD $(I ptrsize)...) $(TD 仮想メンバ関数へのポインタ))
)

	$(P クラスオブジェクトのインターフェイスへのキャストは、
	オブジェクトのベースアドレスに、インターフェイスのvptrへのオフセットを加算することで行われます。
	インターフェイスをクラス型へキャストし直すには、
	引き算する正しいオフセットを求めるために、vtbl[0] の object.Interface エントリを参照します。
	vtbl[] の中には、
	thisポインタが正しくオブジェクトのインスタンスを参照するように調整するための
	サンク が生成され格納されます。
	)

	$(P サンクは以下のようなコードになります:)

$(CCODE
  ADD EAX,offset
  JMP method
)

	$(P 継承関係グラフの左端は、全てのインターフェイスが vptr を共有する、
	単一継承モデルです。
	（インターフェイスの多重継承によって）継承グラフが分岐する度に、
	新し vptr が作られクラスのインスタンスに格納されます。
	また、virtual メソッドがオーバーライドされるたびに、新しく vtbl[]
	が作られ新しいメソッドポインタをそこに格納する必要があります。
	)

	$(P クラス定義：)

---------
class XXXX {
  ....
};
---------

	$(P は、以下のコードを生成します：)

	$(UL
	$(LI ClassXXXX という名前の、Class クラスのインスタンス)

	$(LI StaticClassXXXX という名前の、全ての静的メンバを定義する型)

	$(LI StaticXXXX という名前の、静的メンバを保持する StaticClassXXXX のインスタンス)
	)
)

$(SECTION3 インターフェイス,

	$(P インターフェイスは vtbl[] へのポインタです。
	vtbl[0] は、object.Interface
	クラスの対応するインスタンスへのポインタです。
	残りのエントリ vtbl[1..$] は、
	そのインターフェイスで実装される仮想関数へのポインタが、
	宣言された順番に入ります。
	)

	$(P COM インターフェイスは、通常のインターフェイスと異なり、
	vtbl[0] に object.Interface は入りません。
	vtbl[0..$] のエントリ全てが仮想関数ポインタで、
	宣言された順番に格納されます。
	これは Windows の COM オブジェクトのレイアウトに合わせています。
	)
    $(V2
	$(P C++ インターフェイスは通常のインターフェイスと異なり、
	ターゲット環境での C++
	の単一継承のクラスレイアウトと同じ形式に合わせた実装になります。
	)
    )
)

$(SECTION3 配列,

	$(P 動的な配列の構成は：)

$(TABLE2 動的配列のレイアウト,
$(TR $(TH オフセット) $(TH プロパティ) $(TH 内容))
$(TR $(TD  0) $(TD $(CODE .length)) $(TD  配列のサイズ))
$(TR $(TD  $(I size_t)) $(TD $(CODE .ptr)) $(TD  配列データへのポインタ))
)

	$(P 動的な配列は次のように宣言され：)

---------
type[] array;
---------

	$(P 静的な配列の宣言は次のようになります：)

---------
type[dimension] array;
---------

	$(P 従って、静的な配列のサイズは常に型の一部として静的に得ることが出来ます。
	このため、静的な配列についてはC言語と同様に実装されています。
	静的な配列と動的な配列は簡単に相互変換が可能です。
	)
)

$(SECTION3 連想配列,

	$(P 連想配列は、
	実装ごとに定義される実体へのポインタ一つで構成されます。
	$(V1 現在の実装は
	 $(PHOBOSSRC internal/aaA.d) から参照できます。)
	$(V2 現在の実装は
	 $(DRUNTIMESRC rt/aaA.d) から参照できます。)
	)
)

$(SECTION3 参照型,

	$(P Dには参照型がありますが、明示的に表には出てきません。例えば、クラスは常に
	参照によってアクセスされます。これはすなわち、クラスのインスタンスそのものは決して
	スタックに置かれたり関数のパラメタとして渡したりできないことを意味します。
	)

	$(P 静的な配列を関数へ渡すと、例え静的な配列として宣言されていても、
	結果は実際には静的配列への参照となります。例をあげると：
	)

---------
int[3] abc;
---------

	$(P 関数へ abc を渡す際には、次のような暗黙の変換が引き起こされます：)

---------
void func(int[3] array); // 実際には <intの><サイズ3配列><への参照>
void func(int* p);       // abc は
                         // 先頭要素へのポインタへ変換される
void func(int[] array);	 // abc は動的配列へ変換される
---------
)


$(SECTION3 名前マングリング,

	$(P Dでは、型安全なリンクを実現するために、Dの識別子名を $(I mangling)
	してスコープと型の情報を埋め込んでいます。
	)

$(GRAMMAR
$(I MangledName):
    $(B _D) $(I QualifiedName) $(I Type)
    $(B _D) $(I QualifiedName) $(B M) $(I Type)

$(I QualifiedName):
    $(I SymbolName)
    $(I SymbolName) $(I QualifiedName)

$(I SymbolName):
    $(I LName)
    $(I TemplateInstanceName)
)

	$(P $(B M) は、そのシンボルが
	$(D this) ポインタを必要とする関数であることを表しています。)

	$(P テンプレートのインスタンス名は、
	そのパラメタ型と値をエンコードして保持します：
	)

$(GRAMMAR
$(I TemplateInstanceName):
    $(Number) $(B __T) $(I LName) $(I TemplateArgs) $(B Z)

$(I TemplateArgs):
    $(I TemplateArg)
    $(I TemplateArg) $(I TemplateArgs)

$(I TemplateArg):
    $(B T) $(I Type)
    $(B V) $(I Type) $(I Value)
    $(B S) $(I LName)

$(I Value):
    $(B n)
    $(I Number)
    $(B i) $(I Number)
    $(B N) $(I Number)
    $(B e) $(I HexFloat)
    $(B c) $(I HexFloat) $(B c) $(I HexFloat)
    $(B A) $(I Number) $(I Value)...
    $(B S) $(I Number) $(I Value)...

$(I HexFloat):
    $(B NAN)
    $(B INF)
    $(B NINF)
    $(B N) $(I HexDigits) $(B P) $(I Exponent)
    $(I HexDigits) $(B P) $(I Exponent)

$(I Exponent):
    $(B N) $(I Number)
    $(I Number)

$(I HexDigits):
    $(I HexDigit)
    $(I HexDigit) $(I HexDigits)

$(I HexDigit):
    $(I Digit)
    $(B A)
    $(B B)
    $(B C)
    $(B D)
    $(B E)
    $(B F)
)

$(DL
	$(DT $(B n))
	$(DD は $(B null) 引数を表します)

	$(DT $(I Number))
	$(DD は正の数値リテラルです
	(文字リテラルを含みます))

	$(DT $(B N) $(I Number))
	$(DD は負の数値リテラルです)

	$(DT $(B e) $(I HexFloat))
	$(DD は実数および虚数の浮動小数点数リテラルです。)

	$(DT $(B c) $(I HexFloat) $(B c) $(I HexFloat))
	$(DD は複素数の浮動小数点数リテラルです。)

	$(DT $(I Width) $(I Number) $(B _) $(I HexDigits))
	$(DD $(I Width) は文字列中の文字が
	1 byte ($(B a)), 2 bytes ($(B w)), 4 bytes ($(B d)) のいずれであるかを示します。
	$(I Number)  は文字列中の文字の数です。
	$(I HexDigits) は文字列データの16進表現です。
	)

	$(DT $(B A) $(I Number) $(I Value)...)
	$(DD 配列リテラル。
	$(I Number) が配列の長さを表します。
	通常の配列では $(I Value) が $(I Number) 回繰り返し、
	連想配列では 2 * $(I Number) 回並びます。
	)

	$(DT $(B S) $(I Number) $(I Value)...)
	$(DD 構造体リテラル。$(I Value) が $(I Number) 個並びます。
	)

)

$(GRAMMAR
$(I Name):
    $(I Namestart)
    $(I Namestart) $(I Namechars)

$(I Namestart):
    $(B _)
    $(I Alpha)

$(I Namechar):
    $(I Namestart)
    $(I Digit)

$(I Namechars):
    $(I Namechar)
    $(I Namechar) $(I Namechars)
)

	$(P $(I Name) は標準的なDの識別子です。)

$(GRAMMAR
$(I LName):
    $(I Number) $(I Name)

$(I Number):
    $(I Digit)
    $(I Digit) $(I Number)

$(I Digit):
    $(B 0)
    $(B 1)
    $(B 2)
    $(B 3)
    $(B 4)
    $(B 5)
    $(B 6)
    $(B 7)
    $(B 8)
    $(B 9)
)

	$(P $(I LName) は、先頭に文字数を表す $(I Number)
	のついた $(I Name) です。
	)
)

$(SECTION3 型名のマングリング,

	$(P 型の名前は以下のように単純な一列の文字列になります:)

$(GRAMMAR
$(I Type):
    $(I Shared)
    $(I Const)
    $(I Immutable)
    $(I Wild)
    $(I TypeArray)
$(V2      $(I TypeNewArray)
)    $(I TypeStaticArray)
    $(I TypeAssocArray)
    $(I TypePointer)
    $(I TypeFunction)
    $(I TypeIdent)
    $(I TypeClass)
    $(I TypeStruct)
    $(I TypeEnum)
    $(I TypeTypedef)
    $(I TypeDelegate)
    $(I TypeNone)
    $(I TypeVoid)
    $(I TypeByte)
    $(I TypeUbyte)
    $(I TypeShort)
    $(I TypeUshort)
    $(I TypeInt)
    $(I TypeUint)
    $(I TypeLong)
    $(I TypeUlong)
    $(I TypeFloat)
    $(I TypeDouble)
    $(I TypeReal)
    $(I TypeIfloat)
    $(I TypeIdouble)
    $(I TypeIreal)
    $(I TypeCfloat)
    $(I TypeCdouble)
    $(I TypeCreal)
    $(I TypeBool)
    $(I TypeChar)
    $(I TypeWchar)
    $(I TypeDchar)
    $(I TypeTuple)

$(I Shared):
    $(B O) $(I Type)

$(I Const):
    $(B x) $(I Type)

$(I Immutable):
    $(B y) $(I Type)

$(I Wild):
    $(B Ng) $(I Type)

$(I TypeArray):
    $(B A) $(I Type)

$(V2 $(I TypeNewArray):
    $(B Ne) $(I Type)
)
$(I TypeStaticArray):
    $(B G) $(I Number) $(I Type)

$(I TypeAssocArray):
    $(B H) $(I Type) $(I Type)

$(I TypePointer):
    $(B P) $(I Type)

$(I TypeFunction):
    $(I CallConvention) $(V2 $(I FuncAttrs) )$(I Arguments) $(I ArgClose) $(I Type)

$(I CallConvention):
    $(B F)       $(GREEN // D)
    $(B U)       $(GREEN // C)
    $(B W)       $(GREEN // Windows)
    $(B V)       $(GREEN // Pascal)
    $(B R)       $(GREEN // C++)

$(V2 $(I FuncAttrs):
    $(I FuncAttr)
    $(I FuncAttr) $(I FuncAttrs)

$(I FuncAttr):
    $(I empty)
    $(I FuncAttrPure)
    $(I FuncAttrNothrow)
    $(I FuncAttrProperty)
    $(I FuncAttrRef)
    $(I FuncAttrTrusted)
    $(I FuncAttrSafe)

$(I FuncAttrPure):
    $(B Na)

$(I FuncAttrNothrow):
    $(B Nb)

$(I FuncAttrRef):
    $(B Nc)

$(I FuncAttrProperty):
    $(B Nd)

$(I FuncAttrTrusted):
    $(B Ne)

$(I FuncAttrSafe):
    $(B Nf)
)

$(I Arguments):
    $(I Argument)
    $(I Argument) $(I Arguments)

$(I Argument:)
$(V2
    $(I Argument2)
    $(B M) $(I Argument2)     $(GREEN // scope)

$(I Argument2:)
)    $(I Type)
    $(B J) $(I Type)     $(GREEN // out)
    $(B K) $(I Type)     $(GREEN // ref)
    $(B L) $(I Type)     $(GREEN // lazy)

$(I ArgClose)
    $(B X)     $(GREEN // 可変長引数 (T t,...) 形式)
    $(B Y)     $(GREEN // 可変長引数 (T t...) 形式)
    $(B Z)     $(GREEN // 可変長引数でない)

$(I TypeIdent):
    $(B I) $(I QualifiedName)

$(I TypeClass):
    $(B C) $(I QualifiedName)

$(I TypeStruct):
    $(B S) $(I QualifiedName)

$(I TypeEnum):
    $(B E) $(I QualifiedName)

$(I TypeTypedef):
    $(B T) $(I QualifiedName)

$(I TypeDelegate):
    $(B D) $(I TypeFunction)

$(I TypeNone):
    $(B n)

$(I TypeVoid):
    $(B v)

$(I TypeByte):
    $(B g)

$(I TypeUbyte):
    $(B h)

$(I TypeShort):
    $(B s)

$(I TypeUshort):
    $(B t)

$(I TypeInt):
    $(B i)

$(I TypeUint):
    $(B k)

$(I TypeLong):
    $(B l)

$(I TypeUlong):
    $(B m)

$(I TypeFloat):
    $(B f)

$(I TypeDouble):
    $(B d)

$(I TypeReal):
    $(B e)

$(I TypeIfloat):
    $(B o)

$(I TypeIdouble):
    $(B p)

$(I TypeIreal):
    $(B j)

$(I TypeCfloat):
    $(B q)

$(I TypeCdouble):
    $(B r)

$(I TypeCreal):
    $(B c)

$(I TypeBool):
    $(B b)

$(I TypeChar):
    $(B a)

$(I TypeWchar):
    $(B u)

$(I TypeDchar):
    $(B w)

$(I TypeTuple):
    $(B B) $(I Number) $(I Arguments)
)
)

$(SECTION3 関数呼び出し規約,

	$(P $(D extern (C)) と $(D extern (D))
	と宣言された関数の呼び出し規約は、
	基本的に、ホスト環境で対応するCコンパイラの関数呼び出し規約と一致します。
	例外として、Windows x86 では extern (D) の呼び出し規約は以下のようになっています。
	)

$(SECTION4 レジスター使用規約,

	$(UL

	$(LI EAX, ECX, EDX は作業用レジスタで、
	関数の中で破壊してかまいません)

	$(LI EBX, ESI, EDI, EBP は関数呼び出し前後で保存されなければなりません)

	$(LI EFLAGS は、方向フラグが前方方向でなければならないことを除いて、
	関数呼び出しの間で破壊されると仮定します)

	$(LI 関数呼び出し時には FPU スタックは空になっていること)

	$(LI FPU の制御ワードは関数呼び出し前後で保存されなければなりません)

	$(LI 浮動小数点数の返値は FPU スタックで返却される。
	使わない場合も呼び出し側でスタックをクリアしなければなりません)

	)
)

$(SECTION4 返値,

	$(UL

	$(LI bool, byte, ubyte, short, ushort, int, uint,
	ポインタ, Object, インターフェイス型の返値は、
	EAX レジスタで返されます)

	$(LI long, ulong
	型の引数は EDX,EAX レジスタで返されます。EDX
	に上位ワードが入ります。)

	$(LI float, double, real, ifloat, idouble, ireal
	型の返値は ST0 に返されます)

	$(LI cfloat, cdouble, creal は ST1,ST0 で返されます。ST1
	に実部、ST0 に虚部が入ります。)

	$(LI 動的配列の返値では、ポインタが EDX、
	長さが EAX に入ります。)

	$(LI 連想配列は EAX で返されます。)

	$(V2 $(LI 参照は、ポインタを EAX に入れて返されます))

	$(LI デリゲートは、関数ポインタをEDXに、
	コンテキストポインタをEAXに入れて返されます。)

	$(LI 1, 2, 4 バイトの構造体は EAX で返されます。)

	$(LI 8 バイトの構造体は EDX,EAX レジスタで返されます。
	EDXに上位ワードが入ります。)

	$(LI そのほかのサイズの構造体は、
	関数の隠れ引数として渡されたポインタの指す先に
	返されます。)

	$(LI コンストラクタはthisポインタをEAXに返します。)

	)
)

$(SECTION4 引数,

	$(P 可変個引数でない関数の引数:)

---
	foo(a1, a2, ..., an);
---

	$(P は、以下のように渡されます:)

	$(TABLE
	$(TR $(TD a1))
	$(TR $(TD a2))
	$(TR $(TD ...))
	$(TR $(TD an))
	$(TR $(TD hidden))
	$(TR $(TD this))
	)

	$(P $(I hidden) は、構造体を返す必要があるときに現れます。
	$(I this) は、
	メンバ関数に使うthisポインタや、
	ネストした関数で使うコンテキストポインタを渡すときに現れます。)

	$(P 次の条件が満たされているときには、最後の引数は、
	スタックではなくEAXレジスタで渡されます:)

	$(UL
	$(LI EAX に収まるサイズである)
	$(LI 3バイト構造体ではない)
	$(LI 浮動小数点型でもない)
	)

	$(P 引数は、
	常に４バイト境界に切り上げてスタックに
	push されます。
	上位ワードが先にpushされます。
	$(B out) 引数と $(B ref) 引数はポインタが渡されます。
	静的配列は先頭へのポインタが渡されます。
	Windowsでは、real型は10バイトの量として、
	creal型は20バイトの量としてpushされます。
	Linuxでは、realは12バイト、
	crealは二つの12バイトの量としてpushされます。
	パディングの2バイトは $(SINGLEQUOTE most significant) 側に埋められます。
	)

	$(P 呼び出された関数側が、スタックを復元します。)

	$(P 以下の形式の可変個引数関数の場合は、)

---
	void foo(int p1, int p2, int[] p3...)
	foo(a1, a2, ..., an);
---

	$(P このように引数が渡されます:)

	$(TABLE
	$(TR $(TD p1))
	$(TR $(TD p2))
	$(TR $(TD a3))
	$(TR $(TD hidden))
	$(TR $(TD this))
	)

	$(P 可変個部分は動的配列に変換され、
	あとは通常の関数と全く同様です。)

	$(P 以下の形式の可変個引数関数の場合は、)

---
	void foo(int p1, int p2, ...)
	foo(a1, a2, a3, ..., an);
---

	$(P このように引数が渡されます:)

	$(TABLE
	$(TR $(TD an))
	$(TR $(TD ...))
	$(TR $(TD a3))
	$(TR $(TD a2))
	$(TR $(TD a1))
	$(TR $(TD _arguments))
	$(TR $(TD hidden))
	$(TR $(TD this))
	)

	$(P 呼び出し側がスタックを復元します。
	$(B _argptr) は直接は渡されません。
	呼び出された関数側が計算します。)
)

)

$(SECTION3 例外処理,

    $(SECTION4 Windows,

	$(P Microsoft Windows
	の構造化例外処理の規約に従います。
	)
    )

    $(SECTION4 Linux$(COMMA) FreeBSD$(COMMA) OS X,

	$(P 静的な範囲/ハンドラ対応表を用います。
	これはELFの例外ハンドラテーブルとは互換性がありません。
	EBP/RBPでスタックフレームを保持しているとの仮定の下で、
	スタックをたどります。例外ハンドラテーブル(EHテーブル)を持つ全ての関数で、
	このEBP/RBPの規約が満たされている必要があります。
	)

	$(P 例外ハンドラのあるそれぞれの関数に対して、
	EHテーブルのエントリが生成されます。
	)

	$(TABLE2 EHテーブルエントリ,
	$(TR $(TH フィールド) $(TH 説明))
	$(TR $(TD void*) $(TD 関数の開始アドレス))
	$(TR $(TD DHandlerTable*) $(TD 対応するEHデータへのポインタ))
	$(TR $(TD uint) $(TD 関数のサイズ。バイト単位))
	)

	$(P EHテーブルは、以下の特別なセグメントに配置され、
	リンカによって一つに結合されます。
	)

	$(TABLE2 EHテーブルセグメント,
	$(TR $(TH OS) $(TH セグメント名))
	$(TR $(TD Windows) $(TD FI))
	$(TR $(TD Linux) $(TD .deh_eh))
	$(TROW FreeBSD, .deh_eh)
	$(TR $(TD OS X) $(TD __deh_eh, __DATA))
	)
	$(BR)

	$(P 例外ハンドラのそのほかのデータは任意の箇所に配置されます。
	書き換えは不可能です。)

	$(TABLE2 DHandlerTable,
	$(TR $(TH フィールド) $(TH 説明))
	$(TR $(TD void*) $(TD 関数の開始アドレス))
	$(TR $(TD uint) $(TD ESP/RSPのEBP/RBPからのオフセット))
	$(TR $(TD uint) $(TD 関数の開始アドレスからreturn codeまでのオフセット))
	$(TR $(TD uint) $(TD DHandlerInfo[] の要素数))
	$(TR $(TD DHandlerInfo[]) $(TD ハンドラ情報の配列))
	)
	$(BR)

	$(TABLE2 DHandlerInfo,
	$(TR $(TH フィールド) $(TH 説明))
	$(TR $(TD uint) $(TD 関数の開始アドレスからtry区間の先頭までのオフセット))
	$(TR $(TD uint) $(TD 同、tryの終端までのオフセット))
	$(TR $(TD int) $(TD 一つ前のテーブルのインデックス))
	$(TR $(TD uint) $(TD 0でない場合、テーブルの先頭から DCatchInfo までのオフセット))
	$(TR $(TD void*) $(TD nullでない場合、finallyのコード))
	)
	$(BR)

	$(TABLE2 DCatchInfo,
	$(TR $(TH フィールド) $(TH 説明))
	$(TR $(TD uint) $(TD DCatchBlock[] の要素数<))
	$(TR $(TD DCatchBlock[]) $(TD catch 情報の配列))
	)
	$(BR)

	$(TABLE2 DCatchBlock,
	$(TR $(TH フィールド) $(TH 説明))
	$(TR $(TD ClassInfo) $(TD catchする例外の型))
	$(TR $(TD uint) $(TD catch変数の EBP/RBP からのオフセット))
	$(TR $(TD void*) $(TD catch ハンドラのコード))
	)
    )
)

$(SECTION3 ガベージコレクション,

	$(P インターフェイスが $(D phobos/internal/gc) に存在します)
)

$(SECTION3 実行時補助関数,

	$(P $(D phobos/internal) に存在します)
)

$(SECTION3 モジュール初期化と終了,

	$(P モジュール内の静的コンストラクタは１つの関数へとまとめられます。
	その関数へのポインタが、そのモジュールの
	ModuleInfo インスタンスの
	ctor メンバに格納されます。
	)

	$(P モジュール内の静的コンストラクタは１つの関数へとまとめられます。
	その関数へのポインタが、そのモジュールの
	ModuleInfo インスタンスの
	dtor メンバに格納されます。
	)
)

$(SECTION3 単体テスト,

	$(P モジュール内の静的コンストラクタは１つの関数へとまとめられます。
	その関数へのポインタが、そのモジュールの
	ModuleInfo インスタンスの
	unitTest メンバに格納されます。
	)
)

$(SECTION2 シンボリック・デバッグ,

	$(P D には、既存のC/C++用デバッガでは表現できない型があります。
	動的配列、連想配列、delegate がそれにあたります。
	しかし、一般には関数呼び出し規約が構造体とは異なるために、
	これらを構造体として表現すると
	C/C++ デバッガの動作ミスを引き起こしてしまいます。
	これらデバッガへの対策として、現状では、
	呼び出し規約がマッチするような型を選んでそれで置き換えて表現するようになっています。
	$(B -gc) スイッチを指定した場合、
	$(B dmd) コンパイラはこのような C 形式シンボル情報のみを出力します。
	)

	$(TABLE2 Cデバッガ向け型情報,
	$(TR
	$(TH D の型)
	$(TH C 表現)
	)
	$(TR
	$(TD 動的配列)
	$(TD unsigned long long)
	)
	$(TR
	$(TD 連想配列)
	$(TD void*)
	)
	$(TR
	$(TD delegate)
	$(TD long long)
	)
	$(TR
	$(TD dchar)
	$(TD unsigned long)
	)
	)

	$(P 新しい型を追加できるようなタイプのデバッガでは、
	Dの型を完全サポートするために以下の情報を利用してください。
	)

$(SECTION3 <a name="codeview">Codeview デバッガ拡張</a>,

	$(P D の $(B dchar) 型は
	特別な組み込み型 0x78 として表現されます。)

	$(P D は、$(B LF_OEM) (0x0015) で示される Codeview OEM 汎用型情報レコードを使います。
	形式は以下の通りです：)

	$(TABLE2 D の Codeview OEM 拡張,
	$(TR
	$(TD フィールドサイズ)
	$(TD 2)
	$(TD 2)
	$(TD 2)
	$(TD 2)
	$(TD 2)
	$(TD 2)
	)
	$(TR
	$(TH D の型)
	$(TH Leaf Index)
	$(TH OEM Identifier)
	$(TH recOEM)
	$(TH num indices)
	$(TH type index)
	$(TH type index)
	)
	$(TR
	$(TD 動的配列)
	$(TD LF_OEM)
	$(TD $(I OEM))
	$(TD 1)
	$(TD 2)
	$(TD @$(I index))
	$(TD @$(I element))
	)
	$(TR
	$(TD 連想配列)
	$(TD LF_OEM)
	$(TD $(I OEM))
	$(TD 2)
	$(TD 2)
	$(TD @$(I key))
	$(TD @$(I element))
	)
	$(TR
	$(TD delegate)
	$(TD LF_OEM)
	$(TD $(I OEM))
	$(TD 3)
	$(TD 2)
	$(TD @$(I this))
	$(TD @$(I function))
	)
	)

	$(P )

	$(TABLE
	$(TR
	$(TD $(I OEM))
	$(TD 0x42)
	)
	$(TR
	$(TD $(I index))
	$(TD 配列の添え字のtype index)
	)
	$(TR
	$(TD $(I key))
	$(TD 連想配列のkeyのtype index)
	)
	$(TR
	$(TD $(I element))
	$(TD 連想配列のelementのtype index)
	)
	$(TR
	$(TD $(I this))
	$(TD コンテキストポインタのtype index)
	)
	$(TR
	$(TD $(I function))
	$(TD 関数のtype index)
	)
	)

	$(P Tこれらの拡張は
	$(LINK2 http://www.digitalmars.com/ctg/obj2asm.html, obj2asm) を使うと綺麗に表示できます。

	$(P $(LINK2 http://ddbg.mainia.de/releases.html, Ddbg)
	デバッガがこの拡張に対応しています。)
	)
)

$(SECTION3 $(LNAME2 dwarf, Dwarf デバッガ拡張),
	$(P 以下のleaf typeが追加されます：)

	$(TABLE2 D の Dwarf 拡張,
	$(TR
	$(TH D の型)
	$(TH Identifier)
	$(TH Value)
	$(TH Format)
	)
	$(TR
	$(TD 動的配列)
	$(TD DW_TAG_darray_type)
	$(TD 0x41)
	$(TD DW_AT_type が要素の型)
	)
	$(TR
	$(TD associative array)
	$(TD DW_TAG_aarray_type)
	$(TD 0x42)
	$(TD DW_AT_type が要素の型, DW_AT_containing_type が key の型)
	)
	$(TR
	$(TD delegate)
	$(TD DW_TAG_delegate_type)
	$(TD 0x43)
	$(TD DW_AT_type が関数の型, DW_AT_containing_type が $(SINGLEQUOTE this) の型)
	)
	)

	$(P これらの拡張は
	$(LINK2 http://www.digitalmars.com/ctg/dumpobj.html, dumpobj) を使うと綺麗に表示できます。

	$(P $(LINK2 http://www.zerobugs.org/, ZeroBUGS)
	デバッガがこの拡張に対応しています。)
	)

	$(P これらの Dwarf
	拡張は最近の gcc の追加機能と衝突するため取り除かれています。
	)
)


)

)

Macros:
	TITLE=Application Binary Interface
	WIKI=ABI
	CATEGORY_SPEC=$0