D/ldc
1
0
Fork 0
mirror of https://github.com/xomboverlord/ldc.git synced 2026-01-30 19:43:13 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
Files
eadd5fb6452798bdf900891aae67b7933b02ca6c
ldc/backend/ty.h
Alexey Prokhin caad8cde58 Squashed 'dmd2/' content from commit 10017d5 
git-subtree-dir: dmd2
git-subtree-split: 10017d50eaaff4ecdc37a0153b6c37ea0b004c81
2012-04-05 11:10:48 +04:00

378 lines
12 KiB
C
Raw Blame History

// Copyright (C) 1983-1998 by Symantec
// Copyright (C) 2000-2009 by Digital Mars
// All Rights Reserved
// http://www.digitalmars.com
// Written by Walter Bright
/*
* This source file is made available for personal use
* only. The license is in /dmd/src/dmd/backendlicense.txt
* or /dm/src/dmd/backendlicense.txt
* For any other uses, please contact Digital Mars.
*/
#if __SC__
#pragma once
#endif
#ifndef TY_H
#define TY_H 1
//#define TYjhandle TYnptr // use for Jupiter handle
/*****************************************
* Data types.
* (consists of basic type + modifier bits)
*/
// Basic types.
// casttab[][] in exp2.c depends on the order of this
// typromo[] in cpp.c depends on the order too
enum TYM
{
TYbool = 0,
TYchar = 1,
TYschar = 2, // signed char
TYuchar = 3, // unsigned char
TYchar8 = 4,
TYchar16 = 5,
TYshort = 6,
TYwchar_t = 7,
TYushort = 8, // unsigned short
TYenum = 9, // enumeration value
TYint = 0xA,
TYuint = 0xB, // unsigned
TYlong = 0xC,
TYulong = 0xD, // unsigned long
TYdchar = 0xE, // 32 bit Unicode char
TYllong = 0xF, // 64 bit long
TYullong = 0x10, // 64 bit unsigned long
TYfloat = 0x11, // 32 bit real
TYdouble = 0x12, // 64 bit real
// long double is mapped to either of the following at runtime:
TYdouble_alias = 0x13, // 64 bit real (but distinct for overload purposes)
TYldouble = 0x14, // 80 bit real
// Add imaginary and complex types for D and C99
TYifloat = 0x15,
TYidouble = 0x16,
TYildouble = 0x17,
TYcfloat = 0x18,
TYcdouble = 0x19,
TYcldouble = 0x1A,
TYjhandle = 0x1B, // Jupiter handle type, equals TYnptr except
// that the debug type is different so the
// debugger can distinguish them
TYnullptr = 0x1C,
TYnptr = 0x1D, // data segment relative pointer
TYref = 0x24, // reference to another type
TYvoid = 0x25,
TYstruct = 0x26, // watch tyaggregate()
TYarray = 0x27, // watch tyaggregate()
TYnfunc = 0x28, // near C func
TYnpfunc = 0x2A, // near Cpp func
TYnsfunc = 0x2C, // near stdcall func
TYifunc = 0x2E, // interrupt func
TYptr = 0x33, // generic pointer type
TYmfunc = 0x37, // NT C++ member func
TYjfunc = 0x38, // LINKd D function
TYhfunc = 0x39, // C function with hidden parameter
TYnref = 0x3A, // near reference
TYcent = 0x3C, // 128 bit signed integer
TYucent = 0x3D, // 128 bit unsigned integer
#if TARGET_SEGMENTED
TYsptr = 0x1E, // stack segment relative pointer
TYcptr = 0x1F, // code segment relative pointer
TYf16ptr = 0x20, // special OS/2 far16 pointer
TYfptr = 0x21, // far pointer (has segment and offset)
TYhptr = 0x22, // huge pointer (has segment and offset)
TYvptr = 0x23, // __handle pointer (has segment and offset)
TYffunc = 0x29, // far C func
TYfpfunc = 0x2B, // far Cpp func
TYfsfunc = 0x2D, // far stdcall func
TYf16func = 0x34, // _far16 _pascal function
TYnsysfunc = 0x35, // near __syscall func
TYfsysfunc = 0x36, // far __syscall func
TYfref = 0x3B, // far reference
#endif
#if !MARS
TYmemptr = 0x2F, // pointer to member
TYident = 0x30, // type-argument
TYtemplate = 0x31, // unexpanded class template
TYvtshape = 0x32, // virtual function table
#endif
// SIMD vector types // D type
TYfloat4 = 0x3E, // float[4]
TYdouble2 = 0x3F, // double[2]
TYschar16 = 0x40, // byte[16]
TYuchar16 = 0x41, // ubyte[16]
TYshort8 = 0x42, // short[8]
TYushort8 = 0x43, // ushort[8]
TYlong4 = 0x44, // int[4]
TYulong4 = 0x45, // uint[4]
TYllong2 = 0x46, // long[2]
TYullong2 = 0x47, // ulong[2]
#if MARS
#define TYaarray TYnptr
#define TYdelegate (I64 ? TYcent : TYllong)
#define TYdarray (I64 ? TYucent : TYullong)
#endif
TYMAX = 0x48,
};
#define mTYbasic 0xFF /* bit mask for basic types */
#define tybasic(ty) ((ty) & mTYbasic)
#if TX86
// These change depending on memory model
extern int TYptrdiff, TYsize, TYsize_t;
/* Linkage type */
#define mTYnear 0x0800
#if TARGET_SEGMENTED
#define mTYfar 0x1000
#define mTYcs 0x2000 // in code segment
#endif
#define mTYthread 0x4000
#define mTYLINK 0x7800 // all linkage bits
#define mTYloadds 0x08000
#define mTYexport 0x10000
#define mTYweak 0x00000
#define mTYimport 0x20000
#define mTYnaked 0x40000
#define mTYMOD 0x78000 // all modifier bits
#else
#define TYTARG 0x11
#include "TGty.h" /* Target types */
#endif
/* Modifiers to basic types */
#ifdef JHANDLE
#define mTYarrayhandle 0x200
#else
#define mTYarrayhandle 0x0
#endif
#define mTYconst 0x100
#define mTYvolatile 0x200
#define mTYrestrict 0 // BUG: add for C99
#define mTYmutable 0 // need to add support
#define mTYunaligned 0 // non-zero for PowerPC
#define mTYimmutable 0x00080000 // immutable data
#define mTYshared 0x00100000 // shared data
#define mTYnothrow 0x00200000 // nothrow function
#if !MARS
#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS
#define mTYnoret 0x01000000 // function has no return
#define mTYtransu 0x01000000 // transparent union
#else
#define mTYfar16 0x01000000
#endif
#define mTYstdcall 0x02000000
#define mTYfastcall 0x04000000
#define mTYinterrupt 0x08000000
#define mTYcdecl 0x10000000
#define mTYpascal 0x20000000
#define mTYsyscall 0x40000000
#define mTYjava 0x80000000
#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS
#define mTYTFF 0xFE000000
#else
#define mTYTFF 0xFF000000
#endif
#endif
/* Flags in tytab[] array */
extern unsigned tytab[];
#define TYFLptr 1
#define TYFLreal 2
#define TYFLintegral 4
#define TYFLcomplex 8
#define TYFLimaginary 0x10
#define TYFLuns 0x20
#define TYFLmptr 0x40
#define TYFLfv 0x80 /* TYfptr || TYvptr */
#if TX86
#define TYFLfarfunc 0x100
#define TYFLpascal 0x200 // callee cleans up stack
#define TYFLrevparam 0x400 // function parameters are reversed
#define TYFLxmmreg 0x10000 // can be put in XMM register
#else
#define TYFLcallstkc 0x100 // callee cleans up stack
#define TYFLrevparam 0x200 // function parameters are reversed
#endif
#define TYFLnullptr 0x800
#define TYFLshort 0x1000
#define TYFLaggregate 0x2000
#define TYFLfunc 0x4000
#define TYFLref 0x8000
/* Groupings of types */
#define tyintegral(ty) (tytab[(ty) & 0xFF] & TYFLintegral)
#define tyarithmetic(ty) (tytab[(ty) & 0xFF] & (TYFLintegral | TYFLreal | TYFLimaginary | TYFLcomplex))
#define tyaggregate(ty) (tytab[(ty) & 0xFF] & TYFLaggregate)
#define tyscalar(ty) (tytab[(ty) & 0xFF] & (TYFLintegral | TYFLreal | TYFLimaginary | TYFLcomplex | TYFLptr | TYFLmptr | TYFLnullptr))
#define tyfloating(ty) (tytab[(ty) & 0xFF] & (TYFLreal | TYFLimaginary | TYFLcomplex))
#define tyimaginary(ty) (tytab[(ty) & 0xFF] & TYFLimaginary)
#define tycomplex(ty) (tytab[(ty) & 0xFF] & TYFLcomplex)
#define tyreal(ty) (tytab[(ty) & 0xFF] & TYFLreal)
// Fits into 64 bit register
#define ty64reg(ty) (tytab[(ty) & 0xFF] & (TYFLintegral | TYFLptr) && tysize(ty) <= NPTRSIZE)
// Can go in XMM floating point register
#define tyxmmreg(ty) (tytab[(ty) & 0xFF] & TYFLxmmreg)
// Is a vector type
#define tyvector(ty) (tybasic(ty) >= TYfloat4 && tybasic(ty) <= TYullong2)
#ifndef tyshort
/* Types that are chars or shorts */
#define tyshort(ty) (tytab[(ty) & 0xFF] & TYFLshort)
#endif
/* Detect TYlong or TYulong */
#ifndef tylong
#define tylong(ty) (tybasic(ty) == TYlong || tybasic(ty) == TYulong)
#endif
/* Use to detect a pointer type */
#ifndef typtr
#define typtr(ty) (tytab[(ty) & 0xFF] & TYFLptr)
#endif
/* Use to detect a reference type */
#ifndef tyref
#define tyref(ty) (tytab[(ty) & 0xFF] & TYFLref)
#endif
/* Use to detect a pointer type or a member pointer */
#ifndef tymptr
#define tymptr(ty) (tytab[(ty) & 0xFF] & (TYFLptr | TYFLmptr))
#endif
// Use to detect a nullptr type or a member pointer
#ifndef tynullptr
#define tynullptr(ty) (tytab[(ty) & 0xFF] & TYFLnullptr)
#endif
/* Detect TYfptr or TYvptr */
#ifndef tyfv
#define tyfv(ty) (tytab[(ty) & 0xFF] & TYFLfv)
#endif
/* Array to give the size in bytes of a type, -1 means error */
extern signed char tysize[];
extern signed char tyalignsize[];
// Give size of type
#define tysize(ty) tysize[(ty) & 0xFF]
#define tyalignsize(ty) tyalignsize[(ty) & 0xFF]
/* All data types that fit in exactly 8 bits */
#ifndef tybyte
#define tybyte(ty) (tysize(ty) == 1)
#endif
/* Types that fit into a single machine register */
#ifndef tyreg
#define tyreg(ty) (tysize(ty) <= REGSIZE)
#endif
/* Detect function type */
#ifndef tyfunc
#define tyfunc(ty) (tytab[(ty) & 0xFF] & TYFLfunc)
#endif
/* Detect function type where parameters are pushed left to right */
#ifndef tyrevfunc
#define tyrevfunc(ty) (tytab[(ty) & 0xFF] & TYFLrevparam)
#endif
/* Detect unsigned types */
#ifndef tyuns
#define tyuns(ty) (tytab[(ty) & 0xFF] & (TYFLuns | TYFLptr))
#endif
/* Target dependent info */
#if TX86
#define TYoffset TYuint /* offset to an address */
/* Detect cpp function type (callee cleans up stack) */
#define typfunc(ty) (tytab[(ty) & 0xFF] & TYFLpascal)
#else
/* Detect cpp function type (callee cleans up stack) */
#ifndef typfunc
#define typfunc(ty) (tytab[(ty) & 0xFF] & TYFLcallstkc)
#endif
#endif
/* Array to convert a type to its unsigned equivalent */
extern const tym_t tytouns[];
#ifndef touns
#define touns(ty) (tytouns[(ty) & 0xFF])
#endif
/* Determine if TYffunc or TYfpfunc (a far function) */
#ifndef tyfarfunc
#define tyfarfunc(ty) (tytab[(ty) & 0xFF] & TYFLfarfunc)
#endif
// Determine if parameter can go in register for TYjfunc
#ifndef tyjparam
#define tyjparam(ty) (tysize(ty) <= NPTRSIZE && !tyfloating(ty) && tybasic(ty) != TYstruct && tybasic(ty) != TYarray)
#endif
/* Determine relaxed type */
#ifndef tyrelax
#define tyrelax(ty) (_tyrelax[tybasic(ty)])
#endif
/* Array to give the 'relaxed' type for relaxed type checking */
extern unsigned char _tyrelax[];
#define type_relax (config.flags3 & CFG3relax) // !=0 if relaxed type checking
#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS
#define type_semirelax (config.flags3 & CFG3semirelax) // !=0 if semi-relaxed type checking
#else
#define type_semirelax type_relax
#endif
/* Determine functionally equivalent type */
extern unsigned char tyequiv[];
/* Give an ascii string for a type */
extern const char *tystring[];
#if TX86
/* Debugger value for type */
extern unsigned char dttab[];
extern unsigned short dttab4[];
#endif
#endif /* TY_H */
Reference in New Issue View Git Blame Copy Permalink