mirror of
https://forge.sourceware.org/marek/gcc.git
synced 2026-02-22 12:00:11 -05:00
155 lines
6.4 KiB
Modula-2
155 lines
6.4 KiB
Modula-2
/* runtime.def -- Definitions for D runtime functions.
|
|
Copyright (C) 2014-2026 Free Software Foundation, Inc.
|
|
|
|
GCC is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3, or (at your option)
|
|
any later version.
|
|
|
|
GCC is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GCC; see the file COPYING3. If not see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
/* D runtime library functions. */
|
|
|
|
/* DEF_D_RUNTIME (CODE, NAME, FLAGS)
|
|
CODE The enum code used to refer to this function.
|
|
NAME The name of this function as a string.
|
|
FLAGS ECF flags to describe attributes of the function.
|
|
|
|
Used for declaring functions that are called by generated code. Most are
|
|
extern(C) - for those that are not, ensure to use correct mangling. */
|
|
|
|
/* Helper macros for parameter building. */
|
|
#define P0() 0
|
|
#define P1(T1) 1, LCT_ ## T1
|
|
#define P2(T1, T2) \
|
|
2, LCT_ ## T1, LCT_ ## T2
|
|
#define P3(T1, T2, T3) \
|
|
3, LCT_ ## T1, LCT_ ## T2, LCT_ ## T3
|
|
#define P4(T1, T2, T3, T4) \
|
|
4, LCT_ ## T1, LCT_ ## T2, LCT_ ## T3, LCT_ ## T4
|
|
#define P5(T1, T2, T3, T4, T5) \
|
|
5, LCT_ ## T1, LCT_ ## T2, LCT_ ## T3, LCT_ ## T4, LCT_ ## T5
|
|
#define RT(T1) LCT_ ## T1
|
|
|
|
/* Used when an assert() contract fails. */
|
|
DEF_D_RUNTIME (ASSERTP, "_d_assertp", RT(VOID), P2(IMMUTABLE_CHARPTR, UINT),
|
|
ECF_NORETURN)
|
|
DEF_D_RUNTIME (ASSERT_MSG, "_d_assert_msg", RT(VOID), P3(STRING, STRING, UINT),
|
|
ECF_NORETURN)
|
|
|
|
/* Used when an assert() contract fails in a unittest function. */
|
|
DEF_D_RUNTIME (UNITTESTP, "_d_unittestp", RT(VOID), P2(IMMUTABLE_CHARPTR, UINT),
|
|
ECF_NORETURN)
|
|
DEF_D_RUNTIME (UNITTEST_MSG, "_d_unittest_msg", RT(VOID),
|
|
P3(STRING, STRING, UINT), ECF_NORETURN)
|
|
|
|
/* Used when an array index outside the bounds of its range. */
|
|
DEF_D_RUNTIME (ARRAYBOUNDSP, "_d_arrayboundsp", RT(VOID),
|
|
P2(IMMUTABLE_CHARPTR, UINT), ECF_NORETURN)
|
|
DEF_D_RUNTIME (ARRAYBOUNDS_SLICEP, "_d_arraybounds_slicep", RT(VOID),
|
|
P5(IMMUTABLE_CHARPTR, UINT, SIZE_T, SIZE_T, SIZE_T),
|
|
ECF_NORETURN)
|
|
DEF_D_RUNTIME (ARRAYBOUNDS_INDEXP, "_d_arraybounds_indexp", RT(VOID),
|
|
P4(IMMUTABLE_CHARPTR, UINT, SIZE_T, SIZE_T), ECF_NORETURN)
|
|
|
|
/* Used when calling delete on a stack-allocated class or interface. */
|
|
DEF_D_RUNTIME (CALLFINALIZER, "_d_callfinalizer", RT(VOID), P1(VOIDPTR), 0)
|
|
DEF_D_RUNTIME (CALLINTERFACEFINALIZER, "_d_callinterfacefinalizer", RT(VOID),
|
|
P1(VOIDPTR), 0)
|
|
|
|
/* Used for casting to a class or interface. */
|
|
DEF_D_RUNTIME (DYNAMIC_CAST, "_d_dynamic_cast", RT(OBJECT),
|
|
P2(OBJECT, CLASSINFO), 0)
|
|
DEF_D_RUNTIME (INTERFACE_CAST, "_d_interface_cast", RT(OBJECT),
|
|
P2(OBJECT, CLASSINFO), 0)
|
|
|
|
/* Used for allocating an array literal on the GC heap. */
|
|
DEF_D_RUNTIME (ARRAYLITERALTX, "_d_arrayliteralTX", RT(VOIDPTR),
|
|
P2(CONST_TYPEINFO, SIZE_T), 0)
|
|
|
|
/* Used for value equality (x == y) and comparisons (x < y) of non-trivial
|
|
arrays. Such as an array of structs or classes. */
|
|
DEF_D_RUNTIME (ADEQ2, "_adEq2", RT(INT),
|
|
P3(ARRAY_VOID, ARRAY_VOID, CONST_TYPEINFO), 0)
|
|
|
|
/* Used for (array.length = n) expressions. The `i' variant is for when the
|
|
initializer is nonzero. */
|
|
DEF_D_RUNTIME (ARRAYSETLENGTHT, "_d_arraysetlengthT", RT(ARRAY_VOID),
|
|
P3(CONST_TYPEINFO, SIZE_T, ARRAYPTR_VOID), 0)
|
|
DEF_D_RUNTIME (ARRAYSETLENGTHIT, "_d_arraysetlengthiT", RT(ARRAY_VOID),
|
|
P3(CONST_TYPEINFO, SIZE_T, ARRAYPTR_VOID), 0)
|
|
|
|
/* Used for allocating closures on the GC heap. */
|
|
DEF_D_RUNTIME (ALLOCMEMORY, "_d_allocmemory", RT(VOIDPTR), P1(SIZE_T),
|
|
ECF_MALLOC)
|
|
|
|
/* Used for copying an array into a slice, adds an enforcment that the source
|
|
and destination are equal in size and do not overlap. */
|
|
DEF_D_RUNTIME (ARRAYCOPY, "_d_arraycopy", RT(ARRAY_VOID),
|
|
P3(SIZE_T, ARRAY_VOID, ARRAY_VOID), 0)
|
|
|
|
/* Used for appending a single element to an array. */
|
|
DEF_D_RUNTIME (ARRAYAPPENDCTX, "_d_arrayappendcTX", RT(ARRAY_BYTE),
|
|
P3(CONST_TYPEINFO, ARRAYPTR_BYTE, SIZE_T), 0)
|
|
|
|
/* Same as appending a single element to an array, but specific for when the
|
|
source is a UTF-32 character, and the destination is a UTF-8 or 16 array. */
|
|
DEF_D_RUNTIME (ARRAYAPPENDCD, "_d_arrayappendcd", RT(ARRAY_VOID),
|
|
P2(ARRAYPTR_BYTE, DCHAR), 0)
|
|
DEF_D_RUNTIME (ARRAYAPPENDWD, "_d_arrayappendwd", RT(ARRAY_VOID),
|
|
P2(ARRAYPTR_BYTE, DCHAR), 0)
|
|
|
|
/* Used for allocating a new associative array. */
|
|
DEF_D_RUNTIME (ASSOCARRAYLITERALTX, "_d_assocarrayliteralTX", RT(VOIDPTR),
|
|
P3(CONST_TYPEINFO, ARRAY_VOID, ARRAY_VOID), 0)
|
|
DEF_D_RUNTIME (AANEW, "_aaNew", RT(VOIDPTR), P1(CONST_TYPEINFO), 0)
|
|
|
|
/* Used for value equality of two associative arrays. */
|
|
DEF_D_RUNTIME (AAEQUAL, "_aaEqual", RT(INT),
|
|
P3(CONST_TYPEINFO, ASSOCARRAY, ASSOCARRAY), 0)
|
|
|
|
/* Used to determine is a key exists in an associative array. */
|
|
DEF_D_RUNTIME (AAINX, "_aaInX", RT(VOIDPTR),
|
|
P3(ASSOCARRAY, CONST_TYPEINFO, VOIDPTR), 0)
|
|
|
|
/* Used to retrieve a value from an associative array index by a key. The
|
|
`Rvalue' variant returns null if the key is not found, where as aaGetY
|
|
will create new key entry for assignment. */
|
|
DEF_D_RUNTIME (AAGETY, "_aaGetY", RT(VOIDPTR),
|
|
P4(POINTER_ASSOCARRAY, CONST_TYPEINFO, SIZE_T, VOIDPTR), 0)
|
|
DEF_D_RUNTIME (AAGETRVALUEX, "_aaGetRvalueX", RT(VOIDPTR),
|
|
P4(ASSOCARRAY, CONST_TYPEINFO, SIZE_T, VOIDPTR), 0)
|
|
|
|
/* Used when calling delete on a key entry in an associative array. */
|
|
DEF_D_RUNTIME (AADELX, "_aaDelX", RT(BOOL),
|
|
P3(ASSOCARRAY, CONST_TYPEINFO, VOIDPTR), 0)
|
|
|
|
/* Used for throw() expressions. */
|
|
DEF_D_RUNTIME (THROW, "_d_throw", RT(VOID), P1(OBJECT), ECF_NORETURN)
|
|
DEF_D_RUNTIME (BEGIN_CATCH, "__gdc_begin_catch", RT(VOIDPTR), P1(VOIDPTR), 0)
|
|
|
|
/* C++ exception handlers. */
|
|
DEF_D_RUNTIME (CXA_BEGIN_CATCH, "__cxa_begin_catch", RT(VOIDPTR), P1(VOIDPTR),
|
|
ECF_NOTHROW)
|
|
DEF_D_RUNTIME (CXA_END_CATCH, "__cxa_end_catch", RT(VOID), P0(), 0)
|
|
|
|
/* When invariant() contracts are turned on, used after testing whether a
|
|
class != null for validating the state of a class. */
|
|
DEF_D_RUNTIME (INVARIANT, "_D2rt10invariant_12_d_invariantFC6ObjectZv",
|
|
RT(VOID), P1(OBJECT), 0)
|
|
|
|
#undef P0
|
|
#undef P1
|
|
#undef P2
|
|
#undef P3
|
|
#undef P4
|
|
#undef P5
|
|
#undef RT
|