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.

Authors

Walter Bright

Source: target.d

  • 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.

    • Declaration

      uint ptrsize;

      size of a pointer in bytes

    • Declaration

      uint realsize;

      size a real consumes in memory

    • Declaration

      uint realpad;

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

    • Declaration

      uint realalignsize;

      alignment for reals

    • Declaration

      uint classinfosize;

      size of ClassInfo

    • Declaration

      ulong maxStaticDataSize;

      maximum size of static data

    • c

      Declaration

      TargetC c;

      C ABI

    • cpp

      Declaration

      TargetCPP cpp;

      C++ ABI

    • Declaration

      TargetObjC objc;

      Objective-C ABI

    • Declaration

      const(char)[] architectureName;

      Architecture name

    • Declaration

      struct FPTypeProperties(T);

      Values representing all properties for floating point types

      • max

        Declaration

        real_t max;

        largest representable value that's not infinity

      • Declaration

        real_t min_normal;

        smallest representable normalized value that's not 0

      • nan

        Declaration

        real_t nan;

        NaN value

      • Declaration

        real_t infinity;

        infinity value

      • Declaration

        real_t epsilon;

        smallest increment to the value 1

      • dig

        Declaration

        d_int64 dig;

        number of decimal digits of precision

      • Declaration

        d_int64 mant_dig;

        number of bits in mantissa

      • Declaration

        d_int64 max_exp;

        maximum int value such that 2 is representable

      • Declaration

        d_int64 min_exp;

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

      • Declaration

        d_int64 max_10_exp;

        maximum int value such that 10

      • Declaration

        d_int64 min_10_exp;

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

    • Declaration

      FPTypeProperties!float FloatProperties;

    • Declaration

      FPTypeProperties!double DoubleProperties;

    • Declaration

      FPTypeProperties!real_t RealProperties;

    • Declaration

      void _init(ref const Param params);

      Initialize the Target

    • 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.

    • 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

    • 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

    • Declaration

      uint critsecsize();

      Size of the target OS critical section.

      Return Value

      size in bytes

    • 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.

    • 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

    • 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

    • Declaration

      LINK systemLinkage();

      Default system linkage for the target.

      Return Value

      LINK to use for extern(System)

    • 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

    • 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

    • 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

    • 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.

    • 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

    • Declaration

      bool isXmmSupported();

      Return Value

      true if xmm usage is supported

    • Declaration

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

      Return Value

      true if generating code for POSIX

  • Declaration

    struct TargetC;

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

    • Declaration

      uint longsize;

      size of a C long or unsigned long type

    • Declaration

      uint long_doublesize;

      size of a C long double

    • Declaration

      uint criticalSectionSize;

      size of os critical section

  • Declaration

    struct TargetCPP;

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

    • Declaration

      bool reverseOverloads;

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

    • Declaration

      bool exceptions;

      set if catching C++ exceptions is supported

    • Declaration

      bool twoDtorInVtable;

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

    • 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

    • 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

    • 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

    • 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.

    • 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

  • Declaration

    struct TargetObjC;

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

    • Declaration

      bool supported;

      set if compiler can interface with Objective-C

  • Declaration

    Target target;