Skip to content


Subversion checkout URL

You can clone with
Download ZIP
Fetching contributors…
Cannot retrieve contributors at this time
1081 lines (851 sloc) 23.4 KB
$(SPEC_S Application Binary Interface,
$(P A D implementation that conforms to the D ABI (Application Binary
will be able to generate libraries, DLL's, etc., that can interoperate
D binaries built by other implementations.
$(P The C ABI referred to in this specification means the C Application
Binary Interface of the target system.
C and D code should be freely linkable together, in particular, D
code shall have access to the entire C ABI runtime library.
$(SECTION3 Endianness,
$(P The $(LINK2, endianness)
(byte order) of the layout of the data
will conform to the endianness of the target machine.
The Intel x86 CPUs are $(I little endian) meaning that
the value 0x0A0B0C0D is stored in memory as:
$(CODE 0D 0C 0B 0A).
$(SECTION3 Basic Types,
$(TROW bool, 8 bit byte with the values 0 for false and 1 for true)
$(TROW byte, 8 bit signed value)
$(TROW ubyte, 8 bit unsigned value)
$(TROW short, 16 bit signed value)
$(TROW ushort, 16 bit unsigned value)
$(TROW int, 32 bit signed value)
$(TROW uint, 32 bit unsigned value)
$(TROW long, 64 bit signed value)
$(TROW ulong, 64 bit unsigned value)
$(TROW cent, 128 bit signed value)
$(TROW ucent, 128 bit unsigned value)
$(TROW float, 32 bit IEEE 754 floating point value)
$(TROW double, 64 bit IEEE 754 floating point value)
$(TROW real, implementation defined floating point value$(COMMA) for x86 it is
80 bit IEEE 754 extended real)
$(SECTION3 Delegates,
$(P Delegates are $(I fat pointers) with two parts:)
$(TABLE2 Delegate Layout,
$(TR $(TH offset) $(TH property) $(TH contents))
$(TR $(TD 0) $(TD $(CODE .ptr)) $(TD context pointer))
$(TR $(TD $(I ptrsize)) $(TD $(CODE .funcptr)) $(TD pointer to function))
$(P The $(I context pointer) can be a class $(I this)
reference, a struct $(I this) pointer, a pointer to
a closure (nested functions) or a pointer to an enclosing
function's stack frame (nested functions).
$(SECTION3 Structs,
$(P Conforms to the target's C ABI struct layout.)
$(SECTION3 Classes,
$(P An object consists of:)
$(TABLE2 Class Object Layout,
$(TR $(TH size) $(TH property) $(TH contents))
$(TR $(TD $(I ptrsize)) $(TD $(CODE .__vptr)) $(TD pointer to vtable))
$(TR $(TD $(I ptrsize)) $(TD $(CODE .__monitor)) $(TD monitor))
$(TR $(TD ...) $(TD ...) $(TD super's non-static fields and super's interface vptrs, from least to most derived))
$(TR $(TD ...) $(TD named fields) $(TD non-static fields))
$(TR $(TD $(I ptrsize)...) $(TD  ) $(TD vptr's for any interfaces implemented by this class in left to right, most to least derived, order))
$(P The vtable consists of:)
$(TABLE2 Virtual Function Pointer Table Layout,
$(TR $(TH size) $(TH contents))
$(TR $(TD $(I ptrsize)) $(TD pointer to instance of $(V1 ClassInfo)$(V2 TypeInfo)))
$(TR $(TD $(I ptrsize)...) $(TD pointers to virtual member functions))
$(P Casting a class object to an interface consists of adding the offset of
the interface's corresponding vptr to the address of the base of the object.
Casting an interface ptr back to the class type it came from involves getting
the correct offset to subtract from it from the object.Interface entry at vtbl[0].
Adjustor thunks are created and pointers to them stored in the method entries in the vtbl[]
in order to set the this pointer to the start of the object instance corresponding
to the implementing method.
$(P An adjustor thunk looks like:)
ADD EAX,offset
JMP method
$(P The leftmost side of the inheritance graph of the interfaces all share
their vptrs, this is the single inheritance model.
Every time the inheritance graph forks (for multiple inheritance) a new vptr is created
and stored in the class' instance.
Every time a virtual method is overridden, a new vtbl[] must be created with
the updated method pointers in it.
$(P The class definition:)
class XXXX {
$(P Generates the following:)
$(LI An instance of Class called ClassXXXX.)
$(LI A type called StaticClassXXXX which defines all the static members.)
$(LI An instance of StaticClassXXXX called StaticXXXX for the static members.)
$(SECTION3 Interfaces,
$(P An interface is a pointer to a pointer to a vtbl[].
The vtbl[0] entry is a pointer to the corresponding
instance of the object.Interface class.
The rest of the vtbl[1..$] entries are pointers to the
virtual functions implemented by that interface, in the
order that they were declared.
$(P A COM interface differs from a regular interface in that
there is no object.Interface entry in vtbl[0]; the entries
vtbl[0..$] are all the virtual function pointers, in the order
that they were declared.
This matches the COM object layout used by Windows.
$(P A C++ interface differs from a regular interface in that
it matches the layout of a C++ class using single inheritance
on the target machine.
$(SECTION3 Arrays,
$(P A dynamic array consists of:)
$(TABLE2 Dynamic Array Layout,
$(TR $(TH offset) $(TH property) $(TH contents))
$(TR $(TD 0) $(TD $(CODE .length)) $(TD array dimension))
$(TR $(TD $(I size_t)) $(TD $(CODE .ptr)) $(TD pointer to array data))
$(P A dynamic array is declared as:)
type[] array;
$(P whereas a static array is declared as:)
type[dimension] array;
$(P Thus, a static array always has the dimension statically available as part of the type, and
so it is implemented like in C. Static array's and Dynamic arrays can be easily converted back
and forth to each other.
$(SECTION3 Associative Arrays,
$(P Associative arrays consist of a pointer to an opaque, implementation
defined type.
$(V1 The current implementation is contained in and defined by
$(PHOBOSSRC internal/aaA.d).)
$(V2 The current implementation is contained in and defined by
$(DRUNTIMESRC rt/aaA.d).)
$(SECTION3 Reference Types,
$(P D has reference types, but they are implicit. For example, classes are always
referred to by reference; this means that class instances can never reside on the stack
or be passed as function parameters.
$(P When passing a static array to a function, the result, although declared as a static array, will
actually be a reference to a static array. For example:
int[3] abc;
$(P Passing abc to functions results in these implicit conversions:)
void func(int[3] array); // actually <reference to><array[3] of><int>
void func(int* p); // abc is converted to a pointer
// to the first element
void func(int[] array); // abc is converted to a dynamic array
$(SECTION3 Name Mangling,
$(P D accomplishes typesafe linking by $(I mangling) a D identifier
to include scope and type information.
$(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 The $(B M) means that the symbol is a function that requires
a $(D this) pointer.)
$(P Template Instance Names have the types and values of its parameters
encoded into it:
$(I TemplateInstanceName):
$(I 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 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)
$(DT $(B n))
$(DD is for $(B null) arguments.)
$(DT $(I Number))
$(DD is for positive numeric literals (including
character literals).)
$(DT $(B N) $(I Number))
$(DD is for negative numeric literals.)
$(DT $(B e) $(I HexFloat))
$(DD is for real and imaginary floating point literals.)
$(DT $(B c) $(I HexFloat) $(B c) $(I HexFloat))
$(DD is for complex floating point literals.)
$(DT $(I Width) $(I Number) $(B _) $(I HexDigits))
$(DD $(I Width) is whether the characters
are 1 byte ($(B a)), 2 bytes ($(B w)) or 4 bytes ($(B d)) in size.
$(I Number) is the number of characters in the string.
The $(I HexDigits) are the hex data for the string.
$(DT $(B A) $(I Number) $(I Value)...)
$(DD An array or asssociative array literal.
$(I Number) is the length of the array.
$(I Value) is repeated $(I Number) times for a normal array,
and 2 * $(I Number) times for an associative array.
$(DT $(B S) $(I Number) $(I Value)...)
$(DD A struct literal. $(I Value) is repeated $(I Number) times.
$(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 A $(I Name) is a standard D identifier.)
$(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 An $(I LName) is a name preceded by a $(I Number) giving
the number of characters in the $(I Name).
$(SECTION3 Type Mangling,
$(P Types are mangled using a simple linear scheme:)
$(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:)
$(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 // variadic T t...$(RPAREN) style)
$(B Y) $(GREEN // variadic T t,...$(RPAREN) style)
$(B Z) $(GREEN // not variadic)
$(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 Function Calling Conventions,
$(P The $(D extern (C)) and $(D extern (D)) calling convention matches the C
calling convention
used by the supported C compiler on the host system.
Except that the extern (D) calling convention for Windows x86 is described here.
$(SECTION4 Register Conventions,
$(LI EAX, ECX, EDX are scratch registers and can be destroyed
by a function.)
$(LI EBX, ESI, EDI, EBP must be preserved across function calls.)
$(LI EFLAGS is assumed destroyed across function calls, except
for the direction flag which must be forward.)
$(LI The FPU stack must be empty when calling a function.)
$(LI The FPU control word must be preserved across function calls.)
$(LI Floating point return values are returned on the FPU stack.
These must be cleaned off by the caller, even if they are not used.)
$(SECTION4 Return Value,
$(LI The types bool, byte, ubyte, short, ushort, int, uint,
pointer, Object, and interfaces
are returned in EAX.)
$(LI long and ulong
are returned in EDX,EAX, where EDX gets the most significant
$(LI float, double, real, ifloat, idouble, ireal are returned
in ST0.)
$(LI cfloat, cdouble, creal are returned in ST1,ST0 where ST1
is the real part and ST0 is the imaginary part.)
$(LI Dynamic arrays are returned with the pointer in EDX
and the length in EAX.)
$(LI Associative arrays are returned in EAX.)
$(V2 $(LI References are returned as pointers in EAX.))
$(LI Delegates are returned with the pointer to the function
in EDX and the context pointer in EAX.)
$(LI 1, 2 and 4 byte structs are returned in EAX.)
$(LI 8 byte structs are returned in EDX,EAX, where
EDX gets the most significant half.)
$(LI For other struct sizes,
the return value is stored through a hidden pointer passed as
an argument to the function.)
$(LI Constructors return the this pointer in EAX.)
$(SECTION4 Parameters,
$(P The parameters to the non-variadic function:)
foo(a1, a2, ..., an);
$(P are passed as follows:)
$(TR $(TD a1))
$(TR $(TD a2))
$(TR $(TD ...))
$(TR $(TD an))
$(TR $(TD hidden))
$(TR $(TD this))
$(P where $(I hidden) is present if needed to return a struct
value, and $(I this) is present if needed as the this pointer
for a member function or the context pointer for a nested
$(P The last parameter is passed in EAX rather than being pushed
on the stack if the following conditions are met:)
$(LI It fits in EAX.)
$(LI It is not a 3 byte struct.)
$(LI It is not a floating point type.)
$(P Parameters are always pushed as multiples of 4 bytes,
rounding upwards,
so the stack is always aligned on 4 byte boundaries.
They are pushed most significant first.
$(B out) and $(B ref) are passed as pointers.
Static arrays are passed as pointers to their first element.
On Windows, a real is pushed as a 10 byte quantity,
a creal is pushed as a 20 byte quantity.
On Linux, a real is pushed as a 12 byte quantity,
a creal is pushed as two 12 byte quantities.
The extra two bytes of pad occupy the $(SINGLEQUOTE most significant) position.
$(P The callee cleans the stack.)
$(P The parameters to the variadic function:)
void foo(int p1, int p2, int[] p3...)
foo(a1, a2, ..., an);
$(P are passed as follows:)
$(TR $(TD p1))
$(TR $(TD p2))
$(TR $(TD a3))
$(TR $(TD hidden))
$(TR $(TD this))
$(P The variadic part is converted to a dynamic array and the
rest is the same as for non-variadic functions.)
$(P The parameters to the variadic function:)
void foo(int p1, int p2, ...)
foo(a1, a2, a3, ..., an);
$(P are passed as follows:)
$(TR $(TD an))
$(TR $(TD ...))
$(TR $(TD a3))
$(TR $(TD a2))
$(TR $(TD a1))
$(TR $(TD _arguments))
$(TR $(TD hidden))
$(TR $(TD this))
$(P The caller is expected to clean the stack.
$(B _argptr) is not
passed, it is computed by the callee.)
$(SECTION3 Exception Handling,
$(SECTION4 Windows,
$(P Conforms to the Microsoft Windows Structured Exception Handling
$(SECTION4 Linux, FreeBSD and OS X,
$(P Uses static address range/handler tables.
It is not compatible with the ELF/Mach-O exception handling tables.
The stack is walked assuming it uses the EBP/RBP stack frame
convention. The EBP/RBP convention must be used for every
function that has an associated EH (Exception Handler) table.
$(P For each function that has exception handlers,
an EH table entry is generated.
$(TABLE2 EH Table Entry,
$(TR $(TH field) $(TH description))
$(TR $(TD void*) $(TD pointer to start of function))
$(TR $(TD DHandlerTable*) $(TD pointer to corresponding EH data))
$(TR $(TD uint) $(TD size in bytes of the function))
$(P The EH table entries are placed into the following special
segments, which are concatenated by the linker.
$(TABLE2 EH Table Segment,
$(TR $(TH Operating System) $(TH Segment Name))
$(TR $(TD Windows) $(TD FI))
$(TR $(TD Linux) $(TD .deh_eh))
$(TROW FreeBSD, .deh_eh)
$(TR $(TD OS X) $(TD __deh_eh, __DATA))
$(P The rest of the EH data can be placed anywhere,
it is immutable.)
$(TABLE2 DHandlerTable,
$(TR $(TH field) $(TH description))
$(TR $(TD void*) $(TD pointer to start of function))
$(TR $(TD uint) $(TD offset of ESP/RSP from EBP/RBP))
$(TR $(TD uint) $(TD offset from start of function to return code))
$(TR $(TD uint) $(TD number of entries in DHandlerInfo[]))
$(TR $(TD DHandlerInfo[]) $(TD array of handler information))
$(TABLE2 DHandlerInfo,
$(TR $(TH field) $(TH description))
$(TR $(TD uint) $(TD offset from function address to start of guarded section))
$(TR $(TD uint) $(TD offset of end of guarded section))
$(TR $(TD int) $(TD previous table index))
$(TR $(TD uint) $(TD if != 0 offset to DCatchInfo data from start of table))
$(TR $(TD void*) $(TD if not null, pointer to finally code to execute))
$(TABLE2 DCatchInfo,
$(TR $(TH field) $(TH description))
$(TR $(TD uint) $(TD number of entries in DCatchBlock[]))
$(TR $(TD DCatchBlock[]) $(TD array of catch information))
$(TABLE2 DCatchBlock,
$(TR $(TH field) $(TH description))
$(TR $(TD ClassInfo) $(TD catch type))
$(TR $(TD uint) $(TD offset from EBP/RBP to catch variable))
$(TR $(TD void*) $(TD catch handler code))
$(SECTION3 Garbage Collection,
$(P The interface to this is found in $(D phobos/internal/gc).)
$(SECTION3 Runtime Helper Functions,
$(P These are found in $(D phobos/internal).)
$(SECTION3 Module Initialization and Termination,
$(P All the static constructors for a module are aggregated into a
single function, and a pointer to that function is inserted
into the ctor member of the ModuleInfo instance for that
$(P All the static denstructors for a module are aggregated into a
single function, and a pointer to that function is inserted
into the dtor member of the ModuleInfo instance for that
$(SECTION3 Unit Testing,
$(P All the unit tests for a module are aggregated into a
single function, and a pointer to that function is inserted
into the unitTest member of the ModuleInfo instance for that
$(SECTION2 Symbolic Debugging,
$(P D has types that are not represented in existing C or C++ debuggers.
These are dynamic arrays, associative arrays, and delegates.
Representing these types as structs causes problems because function
calling conventions for structs are often different than that for
these types, which causes C/C++ debuggers to misrepresent things.
For these debuggers, they are represented as a C type which
does match the calling conventions for the type.
The $(B dmd) compiler will generate only C symbolic type info with the
$(B -gc) compiler switch.
$(TABLE2 Types for C Debuggers,
$(TH D type)
$(TH C representation)
$(TD dynamic array)
$(TD unsigned long long)
$(TD associative array)
$(TD void*)
$(TD delegate)
$(TD long long)
$(TD dchar)
$(TD unsigned long)
$(P For debuggers that can be modified to accept new types, the
following extensions help them fully support the types.
$(SECTION3 <a name="codeview">Codeview Debugger Extensions</a>,
$(P The D $(B dchar) type is represented by the special
primitive type 0x78.)
$(P D makes use of the Codeview OEM generic type record
indicated by $(B LF_OEM) (0x0015). The format is:)
$(TABLE2 Codeview OEM Extensions for D,
$(TD field size)
$(TD 2)
$(TD 2)
$(TD 2)
$(TD 2)
$(TD 2)
$(TD 2)
$(TH D Type)
$(TH Leaf Index)
$(TH OEM Identifier)
$(TH recOEM)
$(TH num indices)
$(TH type index)
$(TH type index)
$(TD dynamic array)
$(TD $(I OEM))
$(TD 1)
$(TD 2)
$(TD @$(I index))
$(TD @$(I element))
$(TD associative array)
$(TD $(I OEM))
$(TD 2)
$(TD 2)
$(TD @$(I key))
$(TD @$(I element))
$(TD delegate)
$(TD $(I OEM))
$(TD 3)
$(TD 2)
$(TD @$(I this))
$(TD @$(I function))
$(P Where:)
$(TD $(I OEM))
$(TD 0x42)
$(TD $(I index))
$(TD type index of array index)
$(TD $(I key))
$(TD type index of key)
$(TD $(I element))
$(TD type index of array element)
$(TD $(I this))
$(TD type index of context pointer)
$(TD $(I function))
$(TD type index of function)
$(P These extensions can be pretty-printed
by $(LINK2, obj2asm).
$(P The $(LINK2, Ddbg) debugger
supports them.)
$(SECTION3 $(LNAME2 dwarf, Dwarf Debugger Extensions),
$(P The following leaf types are added:)
$(TABLE2 Dwarf Extensions for D,
$(TH D type)
$(TH Identifier)
$(TH Value)
$(TH Format)
$(TD dynamic array)
$(TD DW_TAG_darray_type)
$(TD 0x41)
$(TD DW_AT_type is element type)
$(TD associative array)
$(TD DW_TAG_aarray_type)
$(TD 0x42)
$(TD DW_AT_type, is element type, DW_AT_containing_type key type)
$(TD delegate)
$(TD DW_TAG_delegate_type)
$(TD 0x43)
$(TD DW_AT_type, is function type, DW_AT_containing_type is $(SINGLEQUOTE this) type)
$(P These extensions can be pretty-printed
by $(LINK2, dumpobj).
$(P The $(LINK2, ZeroBUGS)
debugger supports them.)
$(P Note that these Dwarf extensions have been removed as they conflict with
recent gcc additions.
TITLE=Application Binary Interface
Jump to Line
Something went wrong with that request. Please try again.