# dmd.backend.cdef

Configuration enums/variables for different targets

#### Discussion

Compiler implementation of the D programming language.

#### Authors

Walter Bright

#### License

Boost License 1.0

Source: backend/cdef.d

- `EXIT_BREAK`

  #### Declaration

  `enum int `EXIT_BREAK`;`

  Limits & machine dependent stuff.

- `targ_char`

  #### Declaration

  `alias `targ_char` = byte;`

  Target machine data types as they appear on the host.

- `linkage_t`

  #### Declaration

  `enum `linkage_t`: int;`

  Configuration

- `EHmethod`

  #### Declaration

  `enum `EHmethod`: int;`

  Exception handling method

- `eve`

  #### Declaration

  `union `eve`;`

  Union of all data types. Storage allocated must be the right size of the data on the TARGET, not the host.

- `SC`

  #### Declaration

  `enum `SC`: ubyte;`

  Storage classes

  - `unde`

    #### Declaration

    ``unde``

    undefined

  - `auto_`

    #### Declaration

    ``auto_``

    automatic (stack)

  - `static_`

    #### Declaration

    ``static_``

    statically allocated

  - `thread`

    #### Declaration

    ``thread``

    `thread` local

  - `extern_`

    #### Declaration

    ``extern_``

    external

  - `register`

    #### Declaration

    ``register``

    registered variable

  - `pseudo`

    #### Declaration

    ``pseudo``

    `pseudo` register variable

  - `global`

    #### Declaration

    ``global``

    top level `global` definition

  - `comdat`

    #### Declaration

    ``comdat``

    initialized common block

  - `parameter`

    #### Declaration

    ``parameter``

    function `parameter`

  - `regpar`

    #### Declaration

    ``regpar``

    function register parameter

  - `fastpar`

    #### Declaration

    ``fastpar``

    function parameter passed in register

  - `shadowreg`

    #### Declaration

    ``shadowreg``

    function parameter passed in register, shadowed on stack

  - `typedef_`

    #### Declaration

    ``typedef_``

    type definition

  - `explicit`

    #### Declaration

    ``explicit``

    `explicit`

  - `mutable`

    #### Declaration

    ``mutable``

    `mutable`

  - `label`

    #### Declaration

    ``label``

    goto `label`

  - `struct_`

    #### Declaration

    ``struct_``

    struct/class/union tag name

  - `enum_`

    #### Declaration

    ``enum_``

    enum tag name

  - `field`

    #### Declaration

    ``field``

    bit `field` of struct or union

  - `const_`

    #### Declaration

    ``const_``

    constant integer

  - `member`

    #### Declaration

    ``member``

    `member` of struct or union

  - `anon`

    #### Declaration

    ``anon``

    member of anonymous union

  - `inline`

    #### Declaration

    ``inline``

    for `inline` functions

  - `sinline`

    #### Declaration

    ``sinline``

    for static inline functions

  - `einline`

    #### Declaration

    ``einline``

    for extern inline functions

  - `overload`

    #### Declaration

    ``overload``

    for overloaded function names

  - `friend`

    #### Declaration

    ``friend``

    `friend` of a class

  - `virtual`

    #### Declaration

    ``virtual``

    `virtual` function

  - `locstat`

    #### Declaration

    ``locstat``

    static, but local to a function

  - `template_`

    #### Declaration

    ``template_``

    class template

  - `functempl`

    #### Declaration

    ``functempl``

    function template

  - `ftexpspec`

    #### Declaration

    ``ftexpspec``

    function template explicit specialization

  - `linkage`

    #### Declaration

    ``linkage``

    function `linkage` symbol

  - `public_`

    #### Declaration

    ``public_``

    generate a pubdef for this

  - `comdef`

    #### Declaration

    ``comdef``

    uninitialized common block

  - `bprel`

    #### Declaration

    ``bprel``

    variable at fixed offset from frame pointer

  - `namespace`

    #### Declaration

    ``namespace``

    `namespace`

  - `alias_`

    #### Declaration

    ``alias_``

    alias to another symbol

  - `funcalias`

    #### Declaration

    ``funcalias``

    alias to another function symbol

  - `memalias`

    #### Declaration

    ``memalias``

    alias to base class member

  - `stack`

    #### Declaration

    ``stack``

    offset from `stack` pointer (not frame pointer)

  - `adl`

    #### Declaration

    ``adl``

    list of ADL symbols for overloading