Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Downloads
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Calendar
  - Forums
  - IRC
  - Community Discord
  - Wiki
  - GitHub
  - Issues
  - Get involved
  - Contributors
  - Foundation
  - Security Team
  - Donate
  - Sponsors
- Resources
  - Tour
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - run.dlang.io
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

# dmd.target

Handles target-specific parameters
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

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.
  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.
  uint `ptrsize`;
    size of a pointer in bytes
  uint `realsize`;
    size a real consumes in memory
  uint `realpad`;
    padding added to the CPU real size to bring it up to realsize
  uint `realalignsize`;
    alignment for reals
  uint `classinfosize`;
    size of ClassInfo
  ulong `maxStaticDataSize`;
    maximum size of static data
  TargetC `c`;
    C ABI
  TargetCPP `cpp`;
    C++ ABI
  TargetObjC `objc`;
    Objective-C ABI
  struct `FPTypeProperties`(T);
    Values representing all properties for floating point types
    real_t `max`;
      largest representable value that's not infinity
    real_t `min_normal`;
      smallest representable normalized value that's not 0
    real_t `nan`;
      NaN value
    real_t `infinity`;
      infinity value
    real_t `epsilon`;
      smallest increment to the value 1
    d_int64 `dig`;
      number of decimal digits of precision
    d_int64 `mant_dig`;
      number of bits in mantissa
    d_int64 `max_exp`;
      maximum int value such that 2 `max_exp`-1 is representable
    d_int64 `min_exp`;
      minimum int value such that 2 `min_exp`-1 is representable as a normalized value
    d_int64 `max_10_exp`;
      maximum int value such that 10 `max_10_exp` is representable
    d_int64 `min_10_exp`;
      minimum int value such that 10 `min_10_exp` is representable as a normalized value
  FPTypeProperties!float `FloatProperties`;
  FPTypeProperties!double `DoubleProperties`;
  FPTypeProperties!real_t `RealProperties`;
  void `_init`(ref const Param `params`);
    Initialize the Target
  void `deinitialize`();
    Deinitializes the global state of the compiler.
    This can be used to restore the state set by _init to its original state.
  uint `alignsize`(Type `type`);
    Requested target memory alignment size of the given type.
    Parameters:

    Type `type` | type to inspect

    Returns:
    alignment in bytes
  uint `fieldalign`(Type `type`);
    Requested target field alignment size of the given type.
    Parameters:

    Type `type` | type to inspect

    Returns:
    alignment in bytes
  uint `critsecsize`();
    Size of the target OS critical section.
    Returns:
    size in bytes
  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.

    Returns:
    Type that represents va_list.
  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

    Returns:
    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
  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

    Returns:
    true if the operation is supported or type is not a vector
  LINK `systemLinkage`();
    Default system linkage for the target.
    Returns:
    LINK to use for extern(System)
  TypeTuple `toArgTypes`(Type `t`);
    Describes how an argument type is passed to a function on target.
    Parameters:

    Type `t` | type to break down

    Returns:
    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
  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

    Returns:
    true if return value from function is on the stack
  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

    Returns:
    size used on parameter stack
  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

    Returns:
    Expression for the requested targetInfo
  bool `isXmmSupported`();
    Returns:
    true if xmm usage is supported
  const nothrow @nogc @property scope bool `isPOSIX`();
    Returns:
    true if generating code for POSIX
struct `TargetC`;
  Functions and variables specific to interfacing with extern(C) ABI.
  uint `longsize`;
    size of a C long or unsigned long type
  uint `long_doublesize`;
    size of a C long double
  uint `criticalSectionSize`;
    size of os critical section
struct `TargetCPP`;
  Functions and variables specific to interface with extern(C++) ABI.
  bool `reverseOverloads`;
    set if overloaded functions are grouped and in reverse order (such as in dmc and cl)
  bool `exceptions`;
    set if catching C++ exceptions is supported
  bool `twoDtorInVtable`;
    target C++ ABI puts deleting and non-deleting destructor into vtable
  const(char)* `toMangle`(Dsymbol `s`);
    Mangle the given symbol for C++ ABI.
    Parameters:

    Dsymbol `s` | declaration with C++ linkage

    Returns:
    string mangling of symbol
  const(char)* `typeInfoMangle`(ClassDeclaration `cd`);
    Get RTTI mangling of the given class declaration for C++ ABI.
    Parameters:

    ClassDeclaration `cd` | class with C++ linkage

    Returns:
    string mangling of C++ typeinfo
  const(char)* `typeMangle`(Type `t`);
    Gets vendor-specific type mangling for C++ ABI.
    Parameters:

    Type `t` | type to inspect

    Returns:
    string if type is mangled specially on target null if unhandled
  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.

    Returns:
    Type to use for parameter `p`.
  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

    Returns:
    true if isFundamental was set by function
struct `TargetObjC`;
  Functions and variables specific to interface with extern(Objective-C) ABI.
  bool `supported`;
    set if compiler can interface with Objective-C
Target `target`;

Copyright © 1999-2020 by the D Language Foundation | Page generated by Ddoc on Mon May 11 10:58:13 2020