D Application Binary Interface
A D implementation that conforms to the D ABI (Application Binary Interface) will be able to generate libraries, DLL's, etc., that can interoperate with D binaries built by other implementations.Most of this specification remains TBD (To Be Defined).
C ABI
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.Basic Types
TBDStructs
Conforms to the target's C ABI struct layout.Classes
An object consists of:
offset | contents |
---|---|
0 | pointer to vtable |
4 | monitor |
8... | non-static members |
The vtable consists of:
offset | contents |
---|---|
0 | pointer to instance of ClassInfo |
4... | pointers to virtual member functions |
The class definition:
class XXXX
{
....
};
Generates the following:
- An instance of Class called ClassXXXX.
- A type called StaticClassXXXX which defines all the static members.
- An instance of StaticClassXXXX called StaticXXXX for the static members.
Interfaces
TBDArrays
A dynamic array consists of:
offset | contents |
---|---|
0 | array dimension |
4 | pointer to array data |
A dynamic array is declared as:
type array[];whereas a static array is declared as:
type array[dimension];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.
Associative Arrays
TBDReference Types
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.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;
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
Name Mangling
D accomplishes typesafe linking by mangling a D identifier to include scope and type information.MangledName: _D QualifiedName Type QualifiedName: SymbolName SymbolName QualifiedName SymbolName: LName TemplateInstanceNameTemplate Instance Names have the types and values of its parameters encoded into it:
TemplateInstanceName: __T LName TemplateArgs Z TemplateArgs: TemplateArg TemplateArg TemplateArgs TemplateArg: T Type V Type Value S LName Value: n Number N Number e 20HexDigits c 20HexDigits 20HexDigits HexDigits: HexDigit HexDigit HexDigits HexDigit: Digit a b c d e fn is for null arguments.
Number is for positive numeric literals (including character literals).
N Number is for negative numeric literals.
e 20HexDigits is for real and imaginary floating point literals.
c 20HexDigits 20HexDigits is for complex floating point literals.
Width Number _ HexDigits: Width is whether the characters are 1 byte (a), 2 bytes (w) or 4 bytes (d) in size. Number is the number of characters in the string. The HexDigits are the hex data for the string.
Name: Namestart Namestart Namechars Namestart: _ Alpha Namechar: Namestart Digit Namechars: Namechar Namechar Namechars
Type: TBDA Name is a standard D identifier.
LName: Number Name Number: Digit Digit Number Digit: 0 1 2 3 4 5 6 7 8 9An LName is a name preceded by a Number giving the number of characters in the Name.