]>
Commit | Line | Data |
---|---|---|
b4c522fa | 1 | /* runtime.def -- Definitions for D runtime functions. |
a945c346 | 2 | Copyright (C) 2014-2024 Free Software Foundation, Inc. |
b4c522fa IB |
3 | |
4 | GCC is free software; you can redistribute it and/or modify | |
5 | it under the terms of the GNU General Public License as published by | |
6 | the Free Software Foundation; either version 3, or (at your option) | |
7 | any later version. | |
8 | ||
9 | GCC is distributed in the hope that it will be useful, | |
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | GNU General Public License for more details. | |
13 | ||
14 | You should have received a copy of the GNU General Public License | |
15 | along with GCC; see the file COPYING3. If not see | |
16 | <http://www.gnu.org/licenses/>. */ | |
17 | ||
18 | /* D runtime library functions. */ | |
19 | ||
20 | /* DEF_D_RUNTIME (CODE, NAME, FLAGS) | |
21 | CODE The enum code used to refer to this function. | |
22 | NAME The name of this function as a string. | |
23 | FLAGS ECF flags to describe attributes of the function. | |
24 | ||
25 | Used for declaring functions that are called by generated code. Most are | |
26 | extern(C) - for those that are not, ensure to use correct mangling. */ | |
27 | ||
28 | /* Helper macros for parameter building. */ | |
766f5f87 IB |
29 | #define P0() 0 |
30 | #define P1(T1) 1, LCT_ ## T1 | |
31 | #define P2(T1, T2) \ | |
32 | 2, LCT_ ## T1, LCT_ ## T2 | |
33 | #define P3(T1, T2, T3) \ | |
34 | 3, LCT_ ## T1, LCT_ ## T2, LCT_ ## T3 | |
35 | #define P4(T1, T2, T3, T4) \ | |
36 | 4, LCT_ ## T1, LCT_ ## T2, LCT_ ## T3, LCT_ ## T4 | |
5fee5ec3 IB |
37 | #define P5(T1, T2, T3, T4, T5) \ |
38 | 5, LCT_ ## T1, LCT_ ## T2, LCT_ ## T3, LCT_ ## T4, LCT_ ## T5 | |
766f5f87 | 39 | #define RT(T1) LCT_ ## T1 |
b4c522fa IB |
40 | |
41 | /* Used when an assert() contract fails. */ | |
766f5f87 IB |
42 | DEF_D_RUNTIME (ASSERTP, "_d_assertp", RT(VOID), P2(IMMUTABLE_CHARPTR, UINT), |
43 | ECF_NORETURN) | |
b4c522fa IB |
44 | DEF_D_RUNTIME (ASSERT_MSG, "_d_assert_msg", RT(VOID), P3(STRING, STRING, UINT), |
45 | ECF_NORETURN) | |
46 | ||
47 | /* Used when an assert() contract fails in a unittest function. */ | |
766f5f87 | 48 | DEF_D_RUNTIME (UNITTESTP, "_d_unittestp", RT(VOID), P2(IMMUTABLE_CHARPTR, UINT), |
b4c522fa IB |
49 | ECF_NORETURN) |
50 | DEF_D_RUNTIME (UNITTEST_MSG, "_d_unittest_msg", RT(VOID), | |
51 | P3(STRING, STRING, UINT), ECF_NORETURN) | |
52 | ||
53 | /* Used when an array index outside the bounds of its range. */ | |
766f5f87 IB |
54 | DEF_D_RUNTIME (ARRAYBOUNDSP, "_d_arrayboundsp", RT(VOID), |
55 | P2(IMMUTABLE_CHARPTR, UINT), ECF_NORETURN) | |
5fee5ec3 IB |
56 | DEF_D_RUNTIME (ARRAYBOUNDS_SLICEP, "_d_arraybounds_slicep", RT(VOID), |
57 | P5(IMMUTABLE_CHARPTR, UINT, SIZE_T, SIZE_T, SIZE_T), | |
58 | ECF_NORETURN) | |
59 | DEF_D_RUNTIME (ARRAYBOUNDS_INDEXP, "_d_arraybounds_indexp", RT(VOID), | |
60 | P4(IMMUTABLE_CHARPTR, UINT, SIZE_T, SIZE_T), ECF_NORETURN) | |
b4c522fa | 61 | |
1d98337c | 62 | /* Used when calling delete on a stack-allocated class or interface. */ |
b4c522fa IB |
63 | DEF_D_RUNTIME (CALLFINALIZER, "_d_callfinalizer", RT(VOID), P1(VOIDPTR), 0) |
64 | DEF_D_RUNTIME (CALLINTERFACEFINALIZER, "_d_callinterfacefinalizer", RT(VOID), | |
65 | P1(VOIDPTR), 0) | |
66 | ||
67 | /* Used for casting to a class or interface. */ | |
68 | DEF_D_RUNTIME (DYNAMIC_CAST, "_d_dynamic_cast", RT(OBJECT), | |
69 | P2(OBJECT, CLASSINFO), 0) | |
70 | DEF_D_RUNTIME (INTERFACE_CAST, "_d_interface_cast", RT(OBJECT), | |
71 | P2(OBJECT, CLASSINFO), 0) | |
72 | ||
b4c522fa IB |
73 | /* Used for allocating an array literal on the GC heap. */ |
74 | DEF_D_RUNTIME (ARRAYLITERALTX, "_d_arrayliteralTX", RT(VOIDPTR), | |
75 | P2(CONST_TYPEINFO, SIZE_T), 0) | |
76 | ||
b4c522fa IB |
77 | /* Used for value equality (x == y) and comparisons (x < y) of non-trivial |
78 | arrays. Such as an array of structs or classes. */ | |
79 | DEF_D_RUNTIME (ADEQ2, "_adEq2", RT(INT), | |
80 | P3(ARRAY_VOID, ARRAY_VOID, CONST_TYPEINFO), 0) | |
b4c522fa IB |
81 | |
82 | /* Used for (array.length = n) expressions. The `i' variant is for when the | |
83 | initializer is nonzero. */ | |
84 | DEF_D_RUNTIME (ARRAYSETLENGTHT, "_d_arraysetlengthT", RT(ARRAY_VOID), | |
85 | P3(CONST_TYPEINFO, SIZE_T, ARRAYPTR_VOID), 0) | |
86 | DEF_D_RUNTIME (ARRAYSETLENGTHIT, "_d_arraysetlengthiT", RT(ARRAY_VOID), | |
87 | P3(CONST_TYPEINFO, SIZE_T, ARRAYPTR_VOID), 0) | |
88 | ||
89 | /* Used for allocating closures on the GC heap. */ | |
90 | DEF_D_RUNTIME (ALLOCMEMORY, "_d_allocmemory", RT(VOIDPTR), P1(SIZE_T), | |
91 | ECF_MALLOC) | |
92 | ||
93 | /* Used for copying an array into a slice, adds an enforcment that the source | |
94 | and destination are equal in size and do not overlap. */ | |
95 | DEF_D_RUNTIME (ARRAYCOPY, "_d_arraycopy", RT(ARRAY_VOID), | |
96 | P3(SIZE_T, ARRAY_VOID, ARRAY_VOID), 0) | |
97 | ||
b4c522fa IB |
98 | /* Used for appending a single element to an array. */ |
99 | DEF_D_RUNTIME (ARRAYAPPENDCTX, "_d_arrayappendcTX", RT(ARRAY_BYTE), | |
100 | P3(CONST_TYPEINFO, ARRAYPTR_BYTE, SIZE_T), 0) | |
101 | ||
102 | /* Same as appending a single element to an array, but specific for when the | |
103 | source is a UTF-32 character, and the destination is a UTF-8 or 16 array. */ | |
104 | DEF_D_RUNTIME (ARRAYAPPENDCD, "_d_arrayappendcd", RT(ARRAY_VOID), | |
105 | P2(ARRAYPTR_BYTE, DCHAR), 0) | |
106 | DEF_D_RUNTIME (ARRAYAPPENDWD, "_d_arrayappendwd", RT(ARRAY_VOID), | |
107 | P2(ARRAYPTR_BYTE, DCHAR), 0) | |
108 | ||
b4c522fa IB |
109 | /* Used for allocating a new associative array. */ |
110 | DEF_D_RUNTIME (ASSOCARRAYLITERALTX, "_d_assocarrayliteralTX", RT(VOIDPTR), | |
111 | P3(CONST_TYPEINFO, ARRAY_VOID, ARRAY_VOID), 0) | |
c8dfa79c | 112 | DEF_D_RUNTIME (AANEW, "_aaNew", RT(VOIDPTR), P1(CONST_TYPEINFO), 0) |
b4c522fa IB |
113 | |
114 | /* Used for value equality of two associative arrays. */ | |
115 | DEF_D_RUNTIME (AAEQUAL, "_aaEqual", RT(INT), | |
116 | P3(CONST_TYPEINFO, ASSOCARRAY, ASSOCARRAY), 0) | |
117 | ||
118 | /* Used to determine is a key exists in an associative array. */ | |
119 | DEF_D_RUNTIME (AAINX, "_aaInX", RT(VOIDPTR), | |
120 | P3(ASSOCARRAY, CONST_TYPEINFO, VOIDPTR), 0) | |
121 | ||
122 | /* Used to retrieve a value from an associative array index by a key. The | |
123 | `Rvalue' variant returns null if the key is not found, where as aaGetY | |
124 | will create new key entry for assignment. */ | |
125 | DEF_D_RUNTIME (AAGETY, "_aaGetY", RT(VOIDPTR), | |
126 | P4(POINTER_ASSOCARRAY, CONST_TYPEINFO, SIZE_T, VOIDPTR), 0) | |
127 | DEF_D_RUNTIME (AAGETRVALUEX, "_aaGetRvalueX", RT(VOIDPTR), | |
128 | P4(ASSOCARRAY, CONST_TYPEINFO, SIZE_T, VOIDPTR), 0) | |
129 | ||
130 | /* Used when calling delete on a key entry in an associative array. */ | |
131 | DEF_D_RUNTIME (AADELX, "_aaDelX", RT(BOOL), | |
132 | P3(ASSOCARRAY, CONST_TYPEINFO, VOIDPTR), 0) | |
133 | ||
134 | /* Used for throw() expressions. */ | |
135 | DEF_D_RUNTIME (THROW, "_d_throw", RT(VOID), P1(OBJECT), ECF_NORETURN) | |
136 | DEF_D_RUNTIME (BEGIN_CATCH, "__gdc_begin_catch", RT(VOIDPTR), P1(VOIDPTR), 0) | |
137 | ||
138 | /* C++ exception handlers. */ | |
139 | DEF_D_RUNTIME (CXA_BEGIN_CATCH, "__cxa_begin_catch", RT(VOIDPTR), P1(VOIDPTR), | |
140 | ECF_NOTHROW) | |
141 | DEF_D_RUNTIME (CXA_END_CATCH, "__cxa_end_catch", RT(VOID), P0(), 0) | |
142 | ||
143 | /* When invariant() contracts are turned on, used after testing whether a | |
144 | class != null for validating the state of a class. */ | |
145 | DEF_D_RUNTIME (INVARIANT, "_D9invariant12_d_invariantFC6ObjectZv", RT(VOID), | |
146 | P1(OBJECT), 0) | |
147 | ||
b4c522fa IB |
148 | #undef P0 |
149 | #undef P1 | |
150 | #undef P2 | |
151 | #undef P3 | |
152 | #undef P4 | |
5fee5ec3 | 153 | #undef P5 |
b4c522fa | 154 | #undef RT |