| /** |
| * 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: |
| * - $(LINK2 https://wiki.osdev.org/Target_Triplet, Target Triplets) |
| * - $(LINK2 https://github.com/ldc-developers/ldc, LDC repository) |
| * - $(LINK2 https://github.com/D-Programming-GDC/gcc, GDC repository) |
| * |
| * Copyright: Copyright (C) 1999-2022 by The D Language Foundation, All Rights Reserved |
| * Authors: $(LINK2 https://www.digitalmars.com, Walter Bright) |
| * License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) |
| * Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/target.d, _target.d) |
| * Documentation: https://dlang.org/phobos/dmd_target.html |
| * Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/target.d |
| */ |
| |
| module dmd.target; |
| |
| import dmd.globals : Param; |
| |
| enum CPU : ubyte |
| { |
| x87, |
| mmx, |
| sse, |
| sse2, |
| sse3, |
| ssse3, |
| sse4_1, |
| sse4_2, |
| avx, // AVX1 instruction set |
| avx2, // AVX2 instruction set |
| avx512, // AVX-512 instruction set |
| |
| // Special values that don't survive past the command line processing |
| baseline, // (default) the minimum capability CPU |
| native // the machine the compiler is being run on |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| /** |
| * 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. |
| */ |
| extern (C++) struct Target |
| { |
| import dmd.dscope : Scope; |
| import dmd.expression : Expression; |
| import dmd.func : FuncDeclaration; |
| import dmd.globals : Loc; |
| import dmd.astenums : LINK, TY; |
| import dmd.mtype : Type, TypeFunction, TypeTuple; |
| import dmd.root.ctfloat : real_t; |
| import dmd.statement : Statement; |
| import dmd.tokens : EXP; |
| |
| /// Bit decoding of the Target.OS |
| enum OS : ubyte |
| { |
| /* These are mutually exclusive; one and only one is set. |
| * Match spelling and casing of corresponding version identifiers |
| */ |
| none = 0, |
| linux = 1, |
| Windows = 2, |
| OSX = 4, |
| OpenBSD = 8, |
| FreeBSD = 0x10, |
| Solaris = 0x20, |
| DragonFlyBSD = 0x40, |
| |
| // Combination masks |
| all = linux | Windows | OSX | OpenBSD | FreeBSD | Solaris | DragonFlyBSD, |
| Posix = linux | OSX | OpenBSD | FreeBSD | Solaris | DragonFlyBSD, |
| } |
| |
| OS os; |
| ubyte osMajor; |
| |
| // D ABI |
| ubyte ptrsize; /// size of a pointer in bytes |
| ubyte realsize; /// size a real consumes in memory |
| ubyte realpad; /// padding added to the CPU real size to bring it up to realsize |
| ubyte realalignsize; /// alignment for reals |
| ubyte classinfosize; /// size of `ClassInfo` |
| ulong maxStaticDataSize; /// maximum size of static data |
| |
| /// C ABI |
| TargetC c; |
| |
| /// C++ ABI |
| TargetCPP cpp; |
| |
| /// Objective-C ABI |
| TargetObjC objc; |
| |
| /// Architecture name |
| const(char)[] architectureName; |
| CPU cpu = CPU.baseline; // CPU instruction set to target |
| bool is64bit; // generate 64 bit code for x86_64; true by default for 64 bit dmd |
| bool isLP64; // pointers are 64 bits |
| |
| // Environmental |
| const(char)[] obj_ext; /// extension for object files |
| const(char)[] lib_ext; /// extension for static library files |
| const(char)[] dll_ext; /// extension for dynamic library files |
| bool run_noext; /// allow -run sources without extensions |
| bool omfobj = false; // for Win32: write OMF object files instead of MsCoff |
| /** |
| * Values representing all properties for floating point types |
| */ |
| extern (C++) struct FPTypeProperties(T) |
| { |
| 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 |
| |
| long dig; /// number of decimal digits of precision |
| long mant_dig; /// number of bits in mantissa |
| long max_exp; /// maximum int value such that 2$(SUPERSCRIPT `max_exp-1`) is representable |
| long min_exp; /// minimum int value such that 2$(SUPERSCRIPT `min_exp-1`) is representable as a normalized value |
| long max_10_exp; /// maximum int value such that 10$(SUPERSCRIPT `max_10_exp` is representable) |
| long min_10_exp; /// minimum int value such that 10$(SUPERSCRIPT `min_10_exp`) is representable as a normalized value |
| } |
| |
| FPTypeProperties!float FloatProperties; /// |
| FPTypeProperties!double DoubleProperties; /// |
| FPTypeProperties!real_t RealProperties; /// |
| |
| private Type tvalist; // cached lazy result of va_listType() |
| |
| private const(Param)* params; // cached reference to global.params |
| |
| /** |
| * Initialize the Target |
| */ |
| extern (C++) void _init(ref const Param params); |
| |
| |
| /** |
| * Deinitializes the global state of the compiler. |
| * |
| * This can be used to restore the state set by `_init` to its original |
| * state. |
| */ |
| void deinitialize() |
| { |
| this = this.init; |
| } |
| |
| /** |
| * Requested target memory alignment size of the given type. |
| * Params: |
| * type = type to inspect |
| * Returns: |
| * alignment in bytes |
| */ |
| extern (C++) uint alignsize(Type type); |
| |
| /** |
| * Requested target field alignment size of the given type. |
| * Params: |
| * type = type to inspect |
| * Returns: |
| * alignment in bytes |
| */ |
| extern (C++) uint fieldalign(Type type); |
| |
| /** |
| * 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`. |
| */ |
| extern (C++) Type va_listType(const ref Loc loc, Scope* sc); |
| |
| /** |
| * Checks whether the target supports a vector type. |
| * Params: |
| * sz = vector type size in bytes |
| * 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 |
| */ |
| extern (C++) int isVectorTypeSupported(int sz, Type type); |
| |
| /** |
| * Checks whether the target supports the given operation for vectors. |
| * Params: |
| * type = target type of operation |
| * op = the unary or binary op being done on the `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 |
| */ |
| extern (C++) bool isVectorOpSupported(Type type, EXP op, Type t2 = null); |
| |
| /** |
| * Default system linkage for the target. |
| * Returns: |
| * `LINK` to use for `extern(System)` |
| */ |
| extern (C++) LINK systemLinkage(); |
| |
| /** |
| * Describes how an argument type is passed to a function on target. |
| * Params: |
| * 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 |
| */ |
| extern (C++) TypeTuple toArgTypes(Type t); |
| |
| /** |
| * Determine return style of function - whether in registers or |
| * through a hidden pointer to the caller's stack. |
| * Params: |
| * tf = function type to check |
| * needsThis = true if the function type is for a non-static member function |
| * Returns: |
| * true if return value from function is on the stack |
| */ |
| extern (C++) bool isReturnOnStack(TypeFunction tf, bool needsThis); |
| |
| /** |
| * Decides whether an `in` parameter of the specified POD type is to be |
| * passed by reference or by value. To be used with `-preview=in` only! |
| * Params: |
| * t = type of the `in` parameter, must be a POD |
| * Returns: |
| * `true` if the `in` parameter is to be passed by reference |
| */ |
| extern(C++) bool preferPassByRef(Type t); |
| |
| /** |
| * Get targetInfo by key |
| * Params: |
| * name = name of targetInfo to get |
| * loc = location to use for error messages |
| * Returns: |
| * Expression for the requested targetInfo |
| */ |
| extern (C++) Expression getTargetInfo(const(char)* name, const ref Loc loc); |
| |
| /** |
| * Params: |
| * tf = type of function being called |
| * Returns: `true` if the callee invokes destructors for arguments. |
| */ |
| extern (C++) bool isCalleeDestroyingArgs(TypeFunction tf); |
| |
| /** |
| * Returns true if the implementation for object monitors is always defined |
| * in the D runtime library (rt/monitor_.d). |
| * Params: |
| * fd = function with `synchronized` storage class. |
| * fbody = entire function body of `fd` |
| * Returns: |
| * `false` if the target backend handles synchronizing monitors. |
| */ |
| extern (C++) bool libraryObjectMonitors(FuncDeclaration fd, Statement fbody); |
| |
| /** |
| * Returns true if the target supports `pragma(linkerDirective)`. |
| * Returns: |
| * `false` if the target does not support `pragma(linkerDirective)`. |
| */ |
| extern (C++) bool supportsLinkerDirective() const; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| /** |
| * Functions and variables specific to interfacing with extern(C) ABI. |
| */ |
| struct TargetC |
| { |
| enum Runtime : ubyte |
| { |
| Unspecified, |
| Bionic, |
| DigitalMars, |
| Glibc, |
| Microsoft, |
| Musl, |
| Newlib, |
| UClibc, |
| WASI, |
| } |
| |
| enum BitFieldStyle : ubyte |
| { |
| Unspecified, |
| DM, /// Digital Mars 32 bit C compiler |
| MS, /// Microsoft 32 and 64 bit C compilers |
| /// https://docs.microsoft.com/en-us/cpp/c-language/c-bit-fields?view=msvc-160 |
| /// https://docs.microsoft.com/en-us/cpp/cpp/cpp-bit-fields?view=msvc-160 |
| Gcc_Clang, /// gcc and clang |
| } |
| bool crtDestructorsSupported = true; /// Not all platforms support crt_destructor |
| ubyte boolsize; /// size of a C `_Bool` type |
| ubyte shortsize; /// size of a C `short` or `unsigned short` type |
| ubyte intsize; /// size of a C `int` or `unsigned int` type |
| ubyte longsize; /// size of a C `long` or `unsigned long` type |
| ubyte long_longsize; /// size of a C `long long` or `unsigned long long` type |
| ubyte long_doublesize; /// size of a C `long double` |
| ubyte wchar_tsize; /// size of a C `wchar_t` type |
| Runtime runtime; /// vendor of the C runtime to link against |
| BitFieldStyle bitFieldStyle; /// different C compilers do it differently |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| /** |
| * Functions and variables specific to interface with extern(C++) ABI. |
| */ |
| struct TargetCPP |
| { |
| import dmd.dsymbol : Dsymbol; |
| import dmd.dclass : ClassDeclaration; |
| import dmd.func : FuncDeclaration; |
| import dmd.mtype : Type; |
| |
| enum Runtime : ubyte |
| { |
| Unspecified, |
| Clang, |
| DigitalMars, |
| Gcc, |
| Microsoft, |
| Sun |
| } |
| 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 |
| bool splitVBasetable; /// set if C++ ABI uses separate tables for virtual functions and virtual bases |
| bool wrapDtorInExternD; /// set if C++ dtors require a D wrapper to be callable from runtime |
| Runtime runtime; /// vendor of the C++ runtime to link against |
| |
| /** |
| * Mangle the given symbol for C++ ABI. |
| * Params: |
| * s = declaration with C++ linkage |
| * Returns: |
| * string mangling of symbol |
| */ |
| extern (C++) const(char)* toMangle(Dsymbol s); |
| |
| /** |
| * Get RTTI mangling of the given class declaration for C++ ABI. |
| * Params: |
| * cd = class with C++ linkage |
| * Returns: |
| * string mangling of C++ typeinfo |
| */ |
| extern (C++) const(char)* typeInfoMangle(ClassDeclaration cd); |
| |
| /** |
| * Get mangle name of a this-adjusting thunk to the given function |
| * declaration for C++ ABI. |
| * Params: |
| * fd = function with C++ linkage |
| * offset = call offset to the vptr |
| * Returns: |
| * string mangling of C++ thunk, or null if unhandled |
| */ |
| extern (C++) const(char)* thunkMangle(FuncDeclaration fd, int offset); |
| |
| /** |
| * Gets vendor-specific type mangling for C++ ABI. |
| * Params: |
| * t = type to inspect |
| * Returns: |
| * string if type is mangled specially on target |
| * null if unhandled |
| */ |
| extern (C++) const(char)* typeMangle(Type t); |
| |
| /** |
| * Get the type that will really be used for passing the given argument |
| * to an `extern(C++)` function, or `null` if unhandled. |
| * Params: |
| * t = type to be passed. |
| * Returns: |
| * `Type` to use for type `t`. |
| */ |
| extern (C++) Type parameterType(Type t); |
| |
| /** |
| * Checks whether type is a vendor-specific fundamental type. |
| * Params: |
| * t = type to inspect |
| * isFundamental = where to store result |
| * Returns: |
| * true if isFundamental was set by function |
| */ |
| extern (C++) bool fundamentalType(const Type t, ref bool isFundamental); |
| |
| /** |
| * Get the starting offset position for fields of an `extern(C++)` class |
| * that is derived from the given base class. |
| * Params: |
| * baseClass = base class with C++ linkage |
| * Returns: |
| * starting offset to lay out derived class fields |
| */ |
| extern (C++) uint derivedClassOffset(ClassDeclaration baseClass); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| /** |
| * Functions and variables specific to interface with extern(Objective-C) ABI. |
| */ |
| struct TargetObjC |
| { |
| bool supported; /// set if compiler can interface with Objective-C |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| extern (C++) __gshared Target target; |
