# dmd.target

Handles `target`-specific parameters

#### Discussion

In order to allow for cross compilation, when the compiler produces a binary for a different platform than it is running on, `target` information needs to be abstracted. This is done in this module, primarily through `Target`.

Note: While DMD itself does not support cross-compilation, GDC and LDC do. Hence, this module is (sometimes heavily) modified by them, and contributors should review how their changes affect them.

#### See Also

- Target Triplets
- LDC repository
- GDC repository

#### Authors

Walter Bright

#### License

Boost License 1.0

Source: target.d

Documentation: https://dlang.org/phobos/dmd_target.html

Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/target.d

- `Target`

  #### Declaration

  `struct `Target`;`

  Describes a back-end target. At present it is incomplete, but in the future it should grow to contain most or all target machine and target O/S specific information.

  #### Discussion

  In many cases, calls to sizeof() can't be used directly for getting data type sizes since cross compiling is supported and would end up using the host sizes rather than the target sizes.

  - `ptrsize`

    #### Declaration

    `uint `ptrsize`;`

    size of a pointer in bytes

  - `realsize`

    #### Declaration

    `uint `realsize`;`

    size a real consumes in memory

  - `realpad`

    #### Declaration

    `uint `realpad`;`

    padding added to the CPU real size to bring it up to realsize

  - `realalignsize`

    #### Declaration

    `uint `realalignsize`;`

    alignment for reals

  - `classinfosize`

    #### Declaration

    `uint `classinfosize`;`

    size of `ClassInfo`

  - `maxStaticDataSize`

    #### Declaration

    `ulong `maxStaticDataSize`;`

    maximum size of static data

  - `c`

    #### Declaration

    `TargetC `c`;`

    C ABI

  - `cpp`

    #### Declaration

    `TargetCPP `cpp`;`

    C++ ABI

  - `objc`

    #### Declaration

    `TargetObjC `objc`;`

    Objective-C ABI

  - `architectureName`

    #### Declaration

    `const(char)[] `architectureName`;`

    Architecture name

  - `FPTypeProperties`

    #### Declaration

    `struct `FPTypeProperties`(T);`

    Values representing all properties for floating point types

    - `max`

      #### Declaration

      `real_t `max`;`

      largest representable value that's not infinity

    - `min_normal`

      #### Declaration

      `real_t `min_normal`;`

      smallest representable normalized value that's not 0

    - `nan`

      #### Declaration

      `real_t `nan`;`

      NaN value

    - `infinity`

      #### Declaration

      `real_t `infinity`;`

      `infinity` value

    - `epsilon`

      #### Declaration

      `real_t `epsilon`;`

      smallest increment to the value 1

    - `dig`

      #### Declaration

      `d_int64 `dig`;`

      number of decimal digits of precision

    - `mant_dig`

      #### Declaration

      `d_int64 `mant_dig`;`

      number of bits in mantissa

    - `max_exp`

      #### Declaration

      `d_int64 `max_exp`;`

      maximum int value such that 2 is representable

    - `min_exp`

      #### Declaration

      `d_int64 `min_exp`;`

      minimum int value such that 2 is representable as a normalized value

    - `max_10_exp`

      #### Declaration

      `d_int64 `max_10_exp`;`

      maximum int value such that 10

    - `min_10_exp`

      #### Declaration

      `d_int64 `min_10_exp`;`

      minimum int value such that 10 is representable as a normalized value

  - `FloatProperties`

    #### Declaration

    `FPTypeProperties!float `FloatProperties`;`

  - `DoubleProperties`

    #### Declaration

    `FPTypeProperties!double `DoubleProperties`;`

  - `RealProperties`

    #### Declaration

    `FPTypeProperties!real_t `RealProperties`;`

  - `_init`

    #### Declaration

    `void `_init`(ref const Param `params`);`

    Initialize the Target

  - `deinitialize`

    #### Declaration

    `void `deinitialize`();`

    Deinitializes the global state of the compiler.

    #### Discussion

    This can be used to restore the state set by `_init` to its original state.

  - `alignsize`

    #### Declaration

    `uint `alignsize`(Type `type`);`

    Requested target memory alignment size of the given `type`.

    #### Parameters

    `Type `type`` | `type` to inspect

    #### Return Value

    alignment in bytes

  - `fieldalign`

    #### Declaration

    `uint `fieldalign`(Type `type`);`

    Requested target field alignment size of the given `type`.

    #### Parameters

    `Type `type`` | `type` to inspect

    #### Return Value

    alignment in bytes

  - `critsecsize`

    #### Declaration

    `uint `critsecsize`();`

    Size of the target OS critical section.

    #### Return Value

    size in bytes

  - `va_listType`

    #### Declaration

    `Type `va_listType`(ref const Loc `loc`, Scope* `sc`);`

    Type for the `va_list` type for the target; e.g., required for `_argptr` declarations.

    NOTE: For Posix/x86_64 this returns the type which will really be used for passing an argument of type va_list.

    #### Return Value

    `Type` that represents `va_list`.

  - `isVectorTypeSupported`

    #### Declaration

    `int `isVectorTypeSupported`(int `sz`, Type `type`);`

    Checks whether the target supports a vector `type`.

    #### Parameters

    `int `sz`` | vector `type` size in bytes
    `Type `type`` | vector element `type`

    #### Return Value

    0 vector `type` is supported, 1 vector `type` is not supported on the target at all 2 vector element `type` is not supported 3 vector size is not supported

  - `isVectorOpSupported`

    #### Declaration

    `bool `isVectorOpSupported`(Type `type`, ubyte `op`, Type `t2` = null);`

    Checks whether the target supports the given operation for vectors.

    #### Parameters

    `Type `type`` | target `type` of operation
    `ubyte `op`` | the unary or binary `op` being done on the ``type``
    `Type `t2`` | `type` of second operand if ``op`` is a binary operation

    #### Return Value

    `true` if the operation is supported or `type` is not a vector

  - `systemLinkage`

    #### Declaration

    `LINK `systemLinkage`();`

    Default system linkage for the target.

    #### Return Value

    `LINK` to use for `extern(System)`

  - `toArgTypes`

    #### Declaration

    `TypeTuple `toArgTypes`(Type `t`);`

    Describes how an argument type is passed to a function on target.

    #### Parameters

    `Type `t`` | type to break down

    #### Return Value

    tuple of types if type is passed in one or more registers empty tuple if type is always passed on the stack `null` if the type is a `void` or argtypes aren'`t` supported by the target

  - `isReturnOnStack`

    #### Declaration

    `bool `isReturnOnStack`(TypeFunction `tf`, bool `needsThis`);`

    Determine return style of function - whether in registers or through a hidden pointer to the caller's stack.

    #### Parameters

    `TypeFunction `tf`` | function type to check
    `bool `needsThis`` | `true` if the function type is for a non-static member function

    #### Return Value

    `true` if return value from function is on the stack

  - `parameterSize`

    #### Declaration

    `ulong `parameterSize`(ref const Loc `loc`, Type `t`);`

    Determine the size a value of type ``t`` will be when it is passed on the function parameter stack.

    #### Parameters

    `Loc `loc`` | location to use for error messages
    `Type `t`` | type of parameter

    #### Return Value

    size used on parameter stack

  - `applyInRefParams`

    #### Declaration

    `void `applyInRefParams`(TypeFunction `tf`);`

    Determine which `in` parameters needs to be passed by `ref`

    #### Discussion

    Called from `TypeFunction` semantic with the full function type. This routine must iterate over parameters, and may set `STC.ref_` for any parameter which already have `STC.in_`. This hook must never set `STC.ref_` if the parameter is not `STC.in_`, nor should it ever change anything else.
    This hook will not be called when `-preview=in` wasn't passed to the frontend, hence it needs not care about `global.params.previewIn`.

    #### Parameters

    `TypeFunction `tf`` | Type of the function to inspect. The type will have its parameter types semantically resolved, however other attributes (return type, `@safe` / `nothrow`, etc...) must not be used.

  - `getTargetInfo`

    #### Declaration

    `Expression `getTargetInfo`(const(char)* `name`, ref const Loc `loc`);`

    Get targetInfo by key

    #### Parameters

    `const(char)* `name`` | `name` of targetInfo to get
    `Loc `loc`` | location to use for error messages

    #### Return Value

    Expression for the requested targetInfo

  - `isXmmSupported`

    #### Declaration

    `bool `isXmmSupported`();`

    #### Return Value

    `true` if xmm usage is supported

  - `isPOSIX`

    #### Declaration

    `const nothrow @nogc @property scope bool `isPOSIX`();`

    #### Return Value

    `true` if generating code for POSIX

- `TargetC`

  #### Declaration

  `struct `TargetC`;`

  Functions and variables specific to interfacing with extern(C) ABI.

  - `longsize`

    #### Declaration

    `uint `longsize`;`

    size of a C `long` or `unsigned long` type

  - `long_doublesize`

    #### Declaration

    `uint `long_doublesize`;`

    size of a C `long double`

  - `criticalSectionSize`

    #### Declaration

    `uint `criticalSectionSize`;`

    size of os critical section

- `TargetCPP`

  #### Declaration

  `struct `TargetCPP`;`

  Functions and variables specific to interface with extern(C++) ABI.

  - `reverseOverloads`

    #### Declaration

    `bool `reverseOverloads`;`

    set if overloaded functions are grouped and in reverse order (such as in dmc and cl)

  - `exceptions`

    #### Declaration

    `bool `exceptions`;`

    set if catching C++ `exceptions` is supported

  - `twoDtorInVtable`

    #### Declaration

    `bool `twoDtorInVtable`;`

    target C++ ABI puts deleting and non-deleting destructor into vtable

  - `toMangle`

    #### Declaration

    `const(char)* `toMangle`(Dsymbol `s`);`

    Mangle the given symbol for C++ ABI.

    #### Parameters

    `Dsymbol `s`` | declaration with C++ linkage

    #### Return Value

    string mangling of symbol

  - `typeInfoMangle`

    #### Declaration

    `const(char)* `typeInfoMangle`(ClassDeclaration `cd`);`

    Get RTTI mangling of the given class declaration for C++ ABI.

    #### Parameters

    `ClassDeclaration `cd`` | class with C++ linkage

    #### Return Value

    string mangling of C++ typeinfo

  - `typeMangle`

    #### Declaration

    `const(char)* `typeMangle`(Type `t`);`

    Gets vendor-specific type mangling for C++ ABI.

    #### Parameters

    `Type `t`` | type to inspect

    #### Return Value

    string if type is mangled specially on target `null` if unhandled

  - `parameterType`

    #### Declaration

    `Type `parameterType`(Parameter `p`);`

    Get the type that will really be used for passing the given argument to an `extern(C++)` function.

    #### Parameters

    `Parameter `p`` | parameter to be passed.

    #### Return Value

    `Type` to use for parameter ``p``.

  - `fundamentalType`

    #### Declaration

    `bool `fundamentalType`(const Type `t`, ref bool `isFundamental`);`

    Checks whether type is a vendor-specific fundamental type.

    #### Parameters

    `Type `t`` | type to inspect
    `bool `isFundamental`` | where to store result

    #### Return Value

    `true` if `isFundamental` was set by function

- `TargetObjC`

  #### Declaration

  `struct `TargetObjC`;`

  Functions and variables specific to interface with extern(Objective-C) ABI.

  - `supported`

    #### Declaration

    `bool `supported`;`

    set if compiler can interface with Objective-C

- `target`

  #### Declaration

  `Target `target`;`