/src/wasm3/source/m3_function.c
Line | Count | Source (jump to first uncovered line) |
1 | | // |
2 | | // m3_function.c |
3 | | // |
4 | | // Created by Steven Massey on 4/7/21. |
5 | | // Copyright © 2021 Steven Massey. All rights reserved. |
6 | | // |
7 | | |
8 | | #include "m3_function.h" |
9 | | #include "m3_env.h" |
10 | | |
11 | | |
12 | | M3Result AllocFuncType (IM3FuncType * o_functionType, u32 i_numTypes) |
13 | 35.9k | { |
14 | 35.9k | *o_functionType = (IM3FuncType) m3_Malloc ("M3FuncType", sizeof (M3FuncType) + i_numTypes); |
15 | 35.9k | return (*o_functionType) ? m3Err_none : m3Err_mallocFailed; |
16 | 35.9k | } |
17 | | |
18 | | |
19 | | bool AreFuncTypesEqual (const IM3FuncType i_typeA, const IM3FuncType i_typeB) |
20 | 95.7k | { |
21 | 95.7k | if (i_typeA->numRets == i_typeB->numRets && i_typeA->numArgs == i_typeB->numArgs) |
22 | 44.6k | { |
23 | 44.6k | return (memcmp (i_typeA->types, i_typeB->types, i_typeA->numRets + i_typeA->numArgs) == 0); |
24 | 44.6k | } |
25 | | |
26 | 51.1k | return false; |
27 | 95.7k | } |
28 | | |
29 | | u16 GetFuncTypeNumParams (const IM3FuncType i_funcType) |
30 | 12.7k | { |
31 | 12.7k | return i_funcType ? i_funcType->numArgs : 0; |
32 | 12.7k | } |
33 | | |
34 | | |
35 | | u8 GetFuncTypeParamType (const IM3FuncType i_funcType, u16 i_index) |
36 | 24.9k | { |
37 | 24.9k | u8 type = c_m3Type_unknown; |
38 | | |
39 | 24.9k | if (i_funcType) |
40 | 24.9k | { |
41 | 24.9k | if (i_index < i_funcType->numArgs) |
42 | 24.9k | { |
43 | 24.9k | type = i_funcType->types [i_funcType->numRets + i_index]; |
44 | 24.9k | } |
45 | 24.9k | } |
46 | | |
47 | 24.9k | return type; |
48 | 24.9k | } |
49 | | |
50 | | |
51 | | |
52 | | u16 GetFuncTypeNumResults (const IM3FuncType i_funcType) |
53 | 20.0k | { |
54 | 20.0k | return i_funcType ? i_funcType->numRets : 0; |
55 | 20.0k | } |
56 | | |
57 | | |
58 | | u8 GetFuncTypeResultType (const IM3FuncType i_funcType, u16 i_index) |
59 | 51.9k | { |
60 | 51.9k | u8 type = c_m3Type_unknown; |
61 | | |
62 | 51.9k | if (i_funcType) |
63 | 51.9k | { |
64 | 51.9k | if (i_index < i_funcType->numRets) |
65 | 51.9k | { |
66 | 51.9k | type = i_funcType->types [i_index]; |
67 | 51.9k | } |
68 | 51.9k | } |
69 | | |
70 | 51.9k | return type; |
71 | 51.9k | } |
72 | | |
73 | | |
74 | | //--------------------------------------------------------------------------------------------------------------- |
75 | | |
76 | | |
77 | | void FreeImportInfo (M3ImportInfo * i_info) |
78 | 23.1k | { |
79 | 23.1k | m3_Free (i_info->moduleUtf8); |
80 | 23.1k | m3_Free (i_info->fieldUtf8); |
81 | 23.1k | } |
82 | | |
83 | | |
84 | | void Function_Release (IM3Function i_function) |
85 | 19.8k | { |
86 | 19.8k | m3_Free (i_function->constants); |
87 | | |
88 | 24.7k | for (int i = 0; i < i_function->numNames; i++) |
89 | 4.90k | { |
90 | | // name can be an alias of fieldUtf8 |
91 | 4.90k | if (i_function->names[i] != i_function->import.fieldUtf8) |
92 | 4.54k | { |
93 | 4.54k | m3_Free (i_function->names[i]); |
94 | 4.54k | } |
95 | 4.90k | } |
96 | | |
97 | 19.8k | FreeImportInfo (& i_function->import); |
98 | | |
99 | 19.8k | if (i_function->ownsWasmCode) |
100 | 0 | m3_Free (i_function->wasm); |
101 | | |
102 | | // Function_FreeCompiledCode (func); |
103 | | |
104 | | # if (d_m3EnableCodePageRefCounting) |
105 | | { |
106 | | m3_Free (i_function->codePageRefs); |
107 | | i_function->numCodePageRefs = 0; |
108 | | } |
109 | | # endif |
110 | 19.8k | } |
111 | | |
112 | | |
113 | | void Function_FreeCompiledCode (IM3Function i_function) |
114 | 0 | { |
115 | | # if (d_m3EnableCodePageRefCounting) |
116 | | { |
117 | | i_function->compiled = NULL; |
118 | | |
119 | | while (i_function->numCodePageRefs--) |
120 | | { |
121 | | IM3CodePage page = i_function->codePageRefs [i_function->numCodePageRefs]; |
122 | | |
123 | | if (--(page->info.usageCount) == 0) |
124 | | { |
125 | | // printf ("free %p\n", page); |
126 | | } |
127 | | } |
128 | | |
129 | | m3_Free (i_function->codePageRefs); |
130 | | |
131 | | Runtime_ReleaseCodePages (i_function->module->runtime); |
132 | | } |
133 | | # endif |
134 | 0 | } |
135 | | |
136 | | |
137 | | cstr_t m3_GetFunctionName (IM3Function i_function) |
138 | 9 | { |
139 | 9 | u16 numNames = 0; |
140 | 9 | cstr_t *names = GetFunctionNames(i_function, &numNames); |
141 | 9 | if (numNames > 0) |
142 | 2 | return names[0]; |
143 | 7 | else |
144 | 7 | return "<unnamed>"; |
145 | 9 | } |
146 | | |
147 | | |
148 | | IM3Module m3_GetFunctionModule (IM3Function i_function) |
149 | 0 | { |
150 | 0 | return i_function ? i_function->module : NULL; |
151 | 0 | } |
152 | | |
153 | | |
154 | | cstr_t * GetFunctionNames (IM3Function i_function, u16 * o_numNames) |
155 | 9 | { |
156 | 9 | if (!i_function || !o_numNames) |
157 | 0 | return NULL; |
158 | | |
159 | 9 | if (i_function->import.fieldUtf8) |
160 | 1 | { |
161 | 1 | *o_numNames = 1; |
162 | 1 | return &i_function->import.fieldUtf8; |
163 | 1 | } |
164 | 8 | else |
165 | 8 | { |
166 | 8 | *o_numNames = i_function->numNames; |
167 | 8 | return i_function->names; |
168 | 8 | } |
169 | 9 | } |
170 | | |
171 | | |
172 | | cstr_t GetFunctionImportModuleName (IM3Function i_function) |
173 | 9 | { |
174 | 9 | return (i_function->import.moduleUtf8) ? i_function->import.moduleUtf8 : ""; |
175 | 9 | } |
176 | | |
177 | | |
178 | | u16 GetFunctionNumArgs (IM3Function i_function) |
179 | 12.9k | { |
180 | 12.9k | u16 numArgs = 0; |
181 | | |
182 | 12.9k | if (i_function) |
183 | 12.9k | { |
184 | 12.9k | if (i_function->funcType) |
185 | 12.9k | numArgs = i_function->funcType->numArgs; |
186 | 12.9k | } |
187 | | |
188 | 12.9k | return numArgs; |
189 | 12.9k | } |
190 | | |
191 | | u8 GetFunctionArgType (IM3Function i_function, u32 i_index) |
192 | 3.17k | { |
193 | 3.17k | u8 type = c_m3Type_none; |
194 | | |
195 | 3.17k | if (i_index < GetFunctionNumArgs (i_function)) |
196 | 3.17k | { |
197 | 3.17k | u32 numReturns = i_function->funcType->numRets; |
198 | | |
199 | 3.17k | type = i_function->funcType->types [numReturns + i_index]; |
200 | 3.17k | } |
201 | | |
202 | 3.17k | return type; |
203 | 3.17k | } |
204 | | |
205 | | |
206 | | u16 GetFunctionNumReturns (IM3Function i_function) |
207 | 4.17k | { |
208 | 4.17k | u16 numReturns = 0; |
209 | | |
210 | 4.17k | if (i_function) |
211 | 4.17k | { |
212 | 4.17k | if (i_function->funcType) |
213 | 4.17k | numReturns = i_function->funcType->numRets; |
214 | 4.17k | } |
215 | | |
216 | 4.17k | return numReturns; |
217 | 4.17k | } |
218 | | |
219 | | |
220 | | u8 GetFunctionReturnType (const IM3Function i_function, u16 i_index) |
221 | 0 | { |
222 | 0 | return i_function ? GetFuncTypeResultType (i_function->funcType, i_index) : c_m3Type_unknown; |
223 | 0 | } |
224 | | |
225 | | |
226 | | u32 GetFunctionNumArgsAndLocals (IM3Function i_function) |
227 | 5.59k | { |
228 | 5.59k | if (i_function) |
229 | 5.59k | return i_function->numLocals + GetFunctionNumArgs (i_function); |
230 | 0 | else |
231 | 0 | return 0; |
232 | 5.59k | } |
233 | | |