File Coverage

lib/SPVM/Builder/src/spvm_vm.c
Criterion Covered Total %
statement 1330 1361 97.7
branch 46 48 95.8
condition n/a
subroutine n/a
pod n/a
total 1376 1409 97.6


line stmt bran cond sub pod time code
1             // Copyright (c) 2023 Yuki Kimoto
2             // MIT License
3              
4             #include
5             #include
6             #include
7             #include
8             #include
9             #include
10             #include
11             #include
12              
13             #include "spvm_api.h"
14             #include "spvm_vm.h"
15             #include "spvm_native.h"
16              
17             #include "spvm_allocator.h"
18              
19             #include "spvm_list.h"
20             #include "spvm_hash.h"
21             #include "spvm_string_buffer.h"
22              
23             #include "spvm_opcode.h"
24             #include "spvm_object.h"
25             #include "spvm_weaken_backref.h"
26              
27             #include "spvm_runtime.h"
28             #include "spvm_runtime_string.h"
29             #include "spvm_runtime_basic_type.h"
30             #include "spvm_runtime_class_var.h"
31             #include "spvm_runtime_field.h"
32             #include "spvm_runtime_method.h"
33              
34             #include "spvm_api_string_buffer.h"
35             #include "spvm_api_allocator.h"
36             #include "spvm_api_runtime.h"
37             #include "spvm_api_basic_type.h"
38             #include "spvm_api_class_var.h"
39             #include "spvm_api_field.h"
40             #include "spvm_api_method.h"
41             #include "spvm_api_arg.h"
42             #include "spvm_api_type.h"
43              
44             #include "spvm_implement.h"
45              
46             static const char* FILE_NAME = "spvm_vm.c";
47              
48 1457635           int32_t SPVM_VM_call_method(SPVM_ENV* env, SPVM_VALUE* stack, SPVM_RUNTIME_METHOD* current_method, int32_t args_width) {
49            
50             // Opcode relative index
51 1457635           register int32_t opcode_rel_index = 0;
52            
53             // Runtime
54 1457635           SPVM_RUNTIME* runtime = env->runtime;
55            
56 1457635           const char* current_method_name = current_method->name;
57            
58             // Current basic type
59 1457635           SPVM_RUNTIME_BASIC_TYPE* current_basic_type = current_method->current_basic_type;
60            
61 1457635           const char* current_basic_type_name = current_basic_type->name;
62            
63             // Operation codes
64 1457635           SPVM_OPCODE* opcodes = current_method->opcodes;
65            
66             // Error
67 1457635           int32_t error_id = 0;
68            
69             // Caught eval error_id
70 1457635           int32_t eval_error_id = 0;
71            
72             // Mortal stack
73 1457635           int32_t* mortal_stack = NULL;
74 1457635           int32_t mortal_stack_top = 0;
75            
76             // object variables
77 1457635           void** object_vars = NULL;
78            
79             // ref variables
80 1457635           void** ref_vars = NULL;
81            
82             // double variables
83 1457635           double* double_vars = NULL;
84            
85             // float variables
86 1457635           float* float_vars = NULL;
87            
88             // long variables
89 1457635           int64_t* long_vars = NULL;
90            
91             // int variables
92 1457635           int32_t* int_vars = NULL;
93            
94             // short variables
95 1457635           int16_t* short_vars = NULL;
96            
97             // byte variables
98 1457635           int8_t* byte_vars = NULL;
99            
100             // Alloc variable memory
101             // Allignment is 8. This is numeric type max byte size
102             // Order 8, 4, 2, 1 numeric variable, and addrress variables
103 1457635           char* call_stack = NULL;
104             {
105             // Numeric area byte size
106 1457635           int32_t numeric_vars_size = 0;
107 1457635           numeric_vars_size += current_method->long_vars_width * 8;
108 1457635           numeric_vars_size += current_method->double_vars_width * 8;
109 1457635           numeric_vars_size += current_method->int_vars_width * 4;
110 1457635           numeric_vars_size += current_method->float_vars_width * 4;
111 1457635           numeric_vars_size += current_method->mortal_stack_length * 4;
112 1457635           numeric_vars_size += current_method->short_vars_width * 2;
113 1457635           numeric_vars_size += current_method->byte_vars_width * 1;
114            
115 1457635 100         if (numeric_vars_size % 8 != 0) {
116 133861           numeric_vars_size += (8 - (numeric_vars_size % 8));
117             }
118            
119             // Address area byte size
120 1457635           int32_t address_vars_size = 0;
121 1457635           address_vars_size += current_method->object_vars_width * sizeof(void*);
122 1457635           address_vars_size += current_method->ref_vars_width * sizeof(void*);
123            
124             // Total area byte size
125 1457635           int32_t total_vars_size = numeric_vars_size + address_vars_size;
126            
127 1457635           call_stack = SPVM_API_new_memory_stack(env, stack, total_vars_size + 1);
128 1457635 50         if (call_stack == NULL) {
129 0           void* exception = env->new_string_nolen_no_mortal(env, stack, SPVM_IMPLEMENT_STRING_LITERALS[SPVM_IMPLEMENT_C_STRING_CALL_STACK_ALLOCATION_FAILED]);
130 0           env->set_exception(env, stack, exception);
131 0           error_id = 1;
132 0           return error_id;
133             }
134              
135 1457635           int32_t call_stack_offset = 0;
136            
137             // Double variables
138 1457635           double_vars = (double*)&call_stack[call_stack_offset];
139 1457635           call_stack_offset += current_method->double_vars_width * 8;
140            
141             // Long varialbes
142 1457635           long_vars = (int64_t*)&call_stack[call_stack_offset];
143 1457635           call_stack_offset += current_method->long_vars_width * 8;
144            
145             // Float variables
146 1457635           float_vars = (float*)&call_stack[call_stack_offset];
147 1457635           call_stack_offset += current_method->float_vars_width * 4;
148            
149             // Int variables
150 1457635           int_vars = (int32_t*)&call_stack[call_stack_offset];
151 1457635           call_stack_offset += current_method->int_vars_width * 4;
152              
153             // Mortal stack
154 1457635           mortal_stack = (int32_t*)&call_stack[call_stack_offset];
155 1457635           call_stack_offset += current_method->mortal_stack_length * 4;
156            
157             // Short variables
158 1457635           short_vars = (int16_t*)&call_stack[call_stack_offset];
159 1457635           call_stack_offset += current_method->short_vars_width * 2;
160              
161             // Byte variables
162 1457635           byte_vars = (int8_t*)&call_stack[call_stack_offset];
163 1457635           call_stack_offset += current_method->byte_vars_width * 1;
164            
165 1457635           call_stack_offset = numeric_vars_size;
166              
167             // Object variables
168 1457635           object_vars = (void**)&call_stack[call_stack_offset];
169 1457635           call_stack_offset += current_method->object_vars_width * sizeof(void*);
170            
171             // Refernce variables
172 1457635           ref_vars = (void**)&call_stack[call_stack_offset];
173 1457635           call_stack_offset += current_method->ref_vars_width * sizeof(void*);
174             }
175            
176 1457635           int32_t object_data_offset = env->api->runtime->get_object_data_offset(env->runtime);
177 1457635           int32_t object_ref_count_offset = env->api->runtime->get_object_ref_count_offset(env->runtime);
178 1457635           int32_t object_length_offset = env->api->runtime->get_object_length_offset(env->runtime);
179            
180             // Buffer for string convertion
181             // double need 17 digit
182             // int64_t need 21 gidit (-9223372036854775808 + (null character))
183             char tmp_buffer[256];
184            
185             // Execute operation codes
186             while (1) {
187 35580948           SPVM_OPCODE* opcode = &(opcodes[opcode_rel_index]);
188            
189 35580948           int32_t opcode_id = opcode->id;
190            
191 35580948           switch (opcode_id) {
192              
193             case SPVM_OPCODE_C_ID_END_METHOD: {
194 1457635           goto label_END_OF_METHOD;
195             }
196             case SPVM_OPCODE_C_ID_GOTO: {
197 307303           opcode_rel_index = opcode->operand0;
198 307303           continue;
199             }
200             case SPVM_OPCODE_C_ID_IF_EQ_ZERO: {
201 495611 100         if (int_vars[0] == 0) {
202 219327           opcode_rel_index = opcode->operand0;
203 219327           continue;
204             }
205 276284           break;
206             }
207             case SPVM_OPCODE_C_ID_IF_NE_ZERO: {
208 998725 100         if (int_vars[0] != 0) {
209 926384           opcode_rel_index = opcode->operand0;
210 926384           continue;
211             }
212 72341           break;
213             }
214             case SPVM_OPCODE_C_ID_GOTO_END_OF_EVAL_ON_EXCEPTION: {
215 951 100         if (__builtin_expect(error_id, 0)) {
216 608           int32_t line = opcode->operand2;
217 608           eval_error_id = error_id;
218 608           error_id = 0;
219 608           env->set_exception(env, stack, env->new_stack_trace_no_mortal(env, stack, env->get_exception(env, stack), current_method, line));
220 608           opcode_rel_index = opcode->operand0;
221 608           continue;
222             }
223 343           break;
224             }
225             case SPVM_OPCODE_C_ID_GOTO_END_OF_METHOD_ON_EXCEPTION: {
226 3195444 100         if (__builtin_expect(error_id, 0)) {
227 538           int32_t line = opcode->operand2;
228 538           env->set_exception(env, stack, env->new_stack_trace_no_mortal(env, stack, env->get_exception(env, stack), current_method, line));
229 538           opcode_rel_index = opcode->operand0;
230 538           continue;
231             }
232 3194906           break;
233             }
234             case SPVM_OPCODE_C_ID_LOOKUP_SWITCH: {
235            
236             // Default branch
237 550           int32_t default_opcode_rel_index = opcode->operand1;
238            
239             // Cases length
240 550           int32_t case_infos_length = opcode->operand2;
241              
242 550 100         if (case_infos_length > 0) {
243             // min
244 547           SPVM_OPCODE* opcode_case_info_min = &(opcodes[opcode_rel_index + 1 + 0]);
245 547           int32_t min = opcode_case_info_min->operand1;
246            
247             // max
248 547           SPVM_OPCODE* opcode_case_info_max = &(opcodes[opcode_rel_index + 1 + case_infos_length - 1]);
249 547           int32_t max = opcode_case_info_max->operand1;
250            
251 667 100         if (int_vars[opcode->operand0] >= min && int_vars[opcode->operand0] <= max) {
    100          
252             // 2 opcode_rel_index searching
253 120           int32_t current_min_pos = 0;
254 120           int32_t current_max_pos = case_infos_length - 1;
255            
256             while (1) {
257 382 100         if (current_max_pos < current_min_pos) {
258 77           opcode_rel_index = default_opcode_rel_index;
259 77           break;
260             }
261 305           int32_t current_half_pos = current_min_pos + (current_max_pos - current_min_pos) / 2;
262 305           SPVM_OPCODE* opcode_case_cur_half = &(opcodes[opcode_rel_index + 1 + current_half_pos]);
263 305           int32_t current_half = opcode_case_cur_half->operand1;
264            
265 305 100         if (int_vars[opcode->operand0] > current_half) {
266 173           current_min_pos = current_half_pos + 1;
267             }
268 132 100         else if (int_vars[opcode->operand0] < current_half) {
269 89           current_max_pos = current_half_pos - 1;
270             }
271             else {
272 43           opcode_rel_index = opcode_case_cur_half->operand2;
273 43           break;
274             }
275 262           }
276             }
277             else {
278 547           opcode_rel_index = default_opcode_rel_index;
279             }
280             }
281             else {
282 3           opcode_rel_index = default_opcode_rel_index;
283             }
284            
285 550           continue;
286             }
287             case SPVM_OPCODE_C_ID_PUSH_MORTAL: {
288 778656           SPVM_IMPLEMENT_PUSH_MORTAL(mortal_stack, mortal_stack_top, opcode->operand0);
289 778656           break;
290             }
291             case SPVM_OPCODE_C_ID_LEAVE_SCOPE: {
292 1203116           int32_t original_mortal_stack_top = opcode->operand0;
293 1203116           SPVM_IMPLEMENT_LEAVE_SCOPE(env, stack, object_vars, mortal_stack, &mortal_stack_top, original_mortal_stack_top);
294 1203116           break;
295             }
296             case SPVM_OPCODE_C_ID_MOVE_BYTE_ZERO: {
297 6           SPVM_IMPLEMENT_MOVE_BYTE_ZERO(byte_vars[opcode->operand0]);
298 6           break;
299             }
300             case SPVM_OPCODE_C_ID_MOVE_SHORT_ZERO: {
301 6           SPVM_IMPLEMENT_MOVE_SHORT_ZERO(short_vars[opcode->operand0]);
302 6           break;
303             }
304             case SPVM_OPCODE_C_ID_MOVE_INT_ZERO: {
305 1475143           SPVM_IMPLEMENT_MOVE_INT_ZERO(int_vars[opcode->operand0]);
306 1475143           break;
307             }
308             case SPVM_OPCODE_C_ID_MOVE_LONG_ZERO: {
309 6           SPVM_IMPLEMENT_MOVE_LONG_ZERO(long_vars[opcode->operand0]);
310 6           break;
311             }
312             case SPVM_OPCODE_C_ID_MOVE_FLOAT_ZERO: {
313 6           SPVM_IMPLEMENT_MOVE_FLOAT_ZERO(float_vars[opcode->operand0]);
314 6           break;
315             }
316             case SPVM_OPCODE_C_ID_MOVE_DOUBLE_ZERO: {
317 8           SPVM_IMPLEMENT_MOVE_DOUBLE_ZERO(double_vars[opcode->operand0]);
318 8           break;
319             }
320             case SPVM_OPCODE_C_ID_MOVE_OBJECT_UNDEF: {
321 1539           SPVM_IMPLEMENT_MOVE_OBJECT_UNDEF(env, stack, &object_vars[opcode->operand0]);
322 1539           break;
323             }
324             case SPVM_OPCODE_C_ID_MOVE_MULNUM_BYTE_ZERO: {
325 15           SPVM_IMPLEMENT_MOVE_MULNUM_BYTE_ZERO(env, stack, &byte_vars[opcode->operand0], opcode->operand2);
326 15           break;
327             }
328             case SPVM_OPCODE_C_ID_MOVE_MULNUM_SHORT_ZERO: {
329 14           SPVM_IMPLEMENT_MOVE_MULNUM_SHORT_ZERO(env, stack, &short_vars[opcode->operand0], opcode->operand2);
330 14           break;
331             }
332             case SPVM_OPCODE_C_ID_MOVE_MULNUM_INT_ZERO: {
333 14           SPVM_IMPLEMENT_MOVE_MULNUM_INT_ZERO(env, stack, &int_vars[opcode->operand0], opcode->operand2);
334 14           break;
335             }
336             case SPVM_OPCODE_C_ID_MOVE_MULNUM_LONG_ZERO: {
337 14           SPVM_IMPLEMENT_MOVE_MULNUM_LONG_ZERO(env, stack, &long_vars[opcode->operand0], opcode->operand2);
338 14           break;
339             }
340             case SPVM_OPCODE_C_ID_MOVE_MULNUM_FLOAT_ZERO: {
341 14           SPVM_IMPLEMENT_MOVE_MULNUM_FLOAT_ZERO(env, stack, &float_vars[opcode->operand0], opcode->operand2);
342 14           break;
343             }
344             case SPVM_OPCODE_C_ID_MOVE_MULNUM_DOUBLE_ZERO: {
345 26           SPVM_IMPLEMENT_MOVE_MULNUM_DOUBLE_ZERO(env, stack, &double_vars[opcode->operand0], opcode->operand2);
346 26           break;
347             }
348             case SPVM_OPCODE_C_ID_MOVE_CONSTANT_BYTE: {
349 14011           SPVM_IMPLEMENT_MOVE_CONSTANT_BYTE(byte_vars[opcode->operand0], (int8_t)(uint8_t)opcode->operand1);
350 14011           break;
351             }
352             case SPVM_OPCODE_C_ID_MOVE_CONSTANT_INT: {
353 3395047           SPVM_IMPLEMENT_MOVE_CONSTANT_INT(int_vars[opcode->operand0], (int32_t)opcode->operand1);
354 3395047           break;
355             }
356             case SPVM_OPCODE_C_ID_MOVE_CONSTANT_LONG: {
357 773           SPVM_IMPLEMENT_MOVE_CONSTANT_LONG(long_vars[opcode->operand0], *(int64_t*)&opcode->operand1);
358 773           break;
359             }
360             case SPVM_OPCODE_C_ID_MOVE_CONSTANT_FLOAT: {
361             SPVM_VALUE value;
362 218           value.ival = (int32_t)opcode->operand1;
363 218           SPVM_IMPLEMENT_MOVE_CONSTANT_FLOAT(float_vars[opcode->operand0], value.fval);
364 218           break;
365             }
366             case SPVM_OPCODE_C_ID_MOVE_CONSTANT_DOUBLE: {
367 519           SPVM_IMPLEMENT_MOVE_CONSTANT_DOUBLE(double_vars[opcode->operand0], *(double*)&opcode->operand1);
368 519           break;
369             }
370             case SPVM_OPCODE_C_ID_MOVE_BYTE: {
371 61           SPVM_IMPLEMENT_MOVE_BYTE(byte_vars[opcode->operand0], byte_vars[opcode->operand1]);
372 61           break;
373             }
374             case SPVM_OPCODE_C_ID_MOVE_SHORT: {
375 61           SPVM_IMPLEMENT_MOVE_SHORT(short_vars[opcode->operand0], short_vars[opcode->operand1]);
376 61           break;
377             }
378             case SPVM_OPCODE_C_ID_MOVE_INT: {
379 655917           SPVM_IMPLEMENT_MOVE_INT(int_vars[opcode->operand0], int_vars[opcode->operand1]);
380 655917           break;
381             }
382             case SPVM_OPCODE_C_ID_MOVE_LONG: {
383 59           SPVM_IMPLEMENT_MOVE_LONG(long_vars[opcode->operand0], long_vars[opcode->operand1]);
384 59           break;
385             }
386             case SPVM_OPCODE_C_ID_MOVE_FLOAT: {
387 53           SPVM_IMPLEMENT_MOVE_FLOAT(float_vars[opcode->operand0], float_vars[opcode->operand1]);
388 53           break;
389             }
390             case SPVM_OPCODE_C_ID_MOVE_DOUBLE: {
391 600056           SPVM_IMPLEMENT_MOVE_DOUBLE(double_vars[opcode->operand0], double_vars[opcode->operand1]);
392 600056           break;
393             }
394             case SPVM_OPCODE_C_ID_MOVE_OBJECT: {
395 6771           SPVM_IMPLEMENT_MOVE_OBJECT(env, stack, &object_vars[opcode->operand0], object_vars[opcode->operand1]);
396 6771           break;
397             }
398             case SPVM_OPCODE_C_ID_MOVE_OBJECT_WITH_TYPE_CHECKING: {
399 340           int32_t cast_basic_type_id = opcode->operand2;
400 340           int32_t cast_type_dimension = opcode->operand3;
401            
402 340           void* cast_basic_type = env->api->runtime->get_basic_type_by_id(env->runtime, cast_basic_type_id);
403            
404 340           SPVM_IMPLEMENT_MOVE_OBJECT_WITH_TYPE_CHECKING(env, stack, &object_vars[opcode->operand0], object_vars[opcode->operand1], cast_basic_type, cast_type_dimension, &error_id);
405 340           break;
406             }
407             case SPVM_OPCODE_C_ID_MOVE_OBJECT_CHECK_READ_ONLY: {
408 2269           SPVM_IMPLEMENT_MOVE_OBJECT_CHECK_READ_ONLY(env, stack, &object_vars[opcode->operand0], object_vars[opcode->operand1], &error_id);
409 2269           break;
410             }
411             case SPVM_OPCODE_C_ID_MOVE_REF: {
412 4           SPVM_IMPLEMENT_MOVE_REF(ref_vars[opcode->operand0], ref_vars[opcode->operand1]);
413 4           break;
414             }
415             case SPVM_OPCODE_C_ID_ADD_INT: {
416 872331           SPVM_IMPLEMENT_ADD_INT(int_vars[opcode->operand0], int_vars[opcode->operand1], int_vars[opcode->operand2]);
417 872331           break;
418             }
419             case SPVM_OPCODE_C_ID_ADD_LONG: {
420 141           SPVM_IMPLEMENT_ADD_LONG(long_vars[opcode->operand0], long_vars[opcode->operand1], long_vars[opcode->operand2]);
421 141           break;
422             }
423             case SPVM_OPCODE_C_ID_ADD_FLOAT: {
424 128           SPVM_IMPLEMENT_ADD_FLOAT(float_vars[opcode->operand0], float_vars[opcode->operand1], float_vars[opcode->operand2]);
425 128           break;
426             }
427             case SPVM_OPCODE_C_ID_ADD_DOUBLE: {
428 600141           SPVM_IMPLEMENT_ADD_DOUBLE(double_vars[opcode->operand0], double_vars[opcode->operand1], double_vars[opcode->operand2]);
429 600141           break;
430             }
431             case SPVM_OPCODE_C_ID_SUBTRACT_INT: {
432 14327           SPVM_IMPLEMENT_SUBTRACT_INT(int_vars[opcode->operand0], int_vars[opcode->operand1], int_vars[opcode->operand2]);
433 14327           break;
434             }
435             case SPVM_OPCODE_C_ID_SUBTRACT_LONG: {
436 43           SPVM_IMPLEMENT_SUBTRACT_LONG(long_vars[opcode->operand0], long_vars[opcode->operand1], long_vars[opcode->operand2]);
437 43           break;
438             }
439             case SPVM_OPCODE_C_ID_SUBTRACT_FLOAT: {
440 40           SPVM_IMPLEMENT_SUBTRACT_FLOAT(float_vars[opcode->operand0], float_vars[opcode->operand1], float_vars[opcode->operand2]);
441 40           break;
442             }
443             case SPVM_OPCODE_C_ID_SUBTRACT_DOUBLE: {
444 41           SPVM_IMPLEMENT_SUBTRACT_DOUBLE(double_vars[opcode->operand0], double_vars[opcode->operand1], double_vars[opcode->operand2]);
445 41           break;
446             }
447             case SPVM_OPCODE_C_ID_MULTIPLY_INT: {
448 3759           SPVM_IMPLEMENT_MULTIPLY_INT(int_vars[opcode->operand0], int_vars[opcode->operand1], int_vars[opcode->operand2]);
449 3759           break;
450             }
451             case SPVM_OPCODE_C_ID_MULTIPLY_LONG: {
452 5           SPVM_IMPLEMENT_MULTIPLY_LONG(long_vars[opcode->operand0], long_vars[opcode->operand1], long_vars[opcode->operand2]);
453 5           break;
454             }
455             case SPVM_OPCODE_C_ID_MULTIPLY_FLOAT: {
456 12           SPVM_IMPLEMENT_MULTIPLY_FLOAT(float_vars[opcode->operand0], float_vars[opcode->operand1], float_vars[opcode->operand2]);
457 12           break;
458             }
459             case SPVM_OPCODE_C_ID_MULTIPLY_DOUBLE: {
460 700015           SPVM_IMPLEMENT_MULTIPLY_DOUBLE(double_vars[opcode->operand0], double_vars[opcode->operand1], double_vars[opcode->operand2]);
461 700015           break;
462             }
463             case SPVM_OPCODE_C_ID_DIVIDE_INT: {
464 531           SPVM_IMPLEMENT_DIVIDE_INT(env, stack, &int_vars[opcode->operand0], int_vars[opcode->operand1], int_vars[opcode->operand2], &error_id);
465 531           break;
466             }
467             case SPVM_OPCODE_C_ID_DIVIDE_LONG: {
468 3           SPVM_IMPLEMENT_DIVIDE_LONG(env, stack, &long_vars[opcode->operand0], long_vars[opcode->operand1], long_vars[opcode->operand2], &error_id);
469 3           break;
470             }
471             case SPVM_OPCODE_C_ID_DIVIDE_FLOAT: {
472 12           SPVM_IMPLEMENT_DIVIDE_FLOAT(float_vars[opcode->operand0], float_vars[opcode->operand1], float_vars[opcode->operand2]);
473 12           break;
474             }
475             case SPVM_OPCODE_C_ID_DIVIDE_DOUBLE: {
476 600203           SPVM_IMPLEMENT_DIVIDE_DOUBLE(double_vars[opcode->operand0], double_vars[opcode->operand1], double_vars[opcode->operand2]);
477 600203           break;
478             }
479             case SPVM_OPCODE_C_ID_DIVIDE_UNSIGNED_INT: {
480 1           SPVM_IMPLEMENT_DIVIDE_UNSIGNED_INT(env, stack, &int_vars[opcode->operand0], int_vars[opcode->operand1], int_vars[opcode->operand2], &error_id);
481 1           break;
482             }
483             case SPVM_OPCODE_C_ID_DIVIDE_UNSIGNED_LONG: {
484 1           SPVM_IMPLEMENT_DIVIDE_UNSIGNED_LONG(env, stack, &long_vars[opcode->operand0], long_vars[opcode->operand1], long_vars[opcode->operand2], &error_id);
485 1           break;
486             }
487             case SPVM_OPCODE_C_ID_REMAINDER_INT: {
488 100031           SPVM_IMPLEMENT_REMAINDER_INT(env, stack, &int_vars[opcode->operand0], int_vars[opcode->operand1], int_vars[opcode->operand2], &error_id);
489 100031           break;
490             }
491             case SPVM_OPCODE_C_ID_REMAINDER_LONG: {
492 7           SPVM_IMPLEMENT_REMAINDER_LONG(env, stack, &long_vars[opcode->operand0], long_vars[opcode->operand1], long_vars[opcode->operand2], &error_id);
493 7           break;
494             }
495             case SPVM_OPCODE_C_ID_REMAINDER_UNSIGNED_INT: {
496 1           SPVM_IMPLEMENT_REMAINDER_UNSIGNED_INT(env, stack, &int_vars[opcode->operand0], int_vars[opcode->operand1], int_vars[opcode->operand2], &error_id);
497 1           break;
498             }
499             case SPVM_OPCODE_C_ID_REMAINDER_UNSIGNED_LONG: {
500 599           SPVM_IMPLEMENT_REMAINDER_UNSIGNED_LONG(env, stack, &long_vars[opcode->operand0], long_vars[opcode->operand1], long_vars[opcode->operand2], &error_id);
501 599           break;
502             }
503             case SPVM_OPCODE_C_ID_LEFT_SHIFT_INT: {
504 15           SPVM_IMPLEMENT_LEFT_SHIFT_INT(int_vars[opcode->operand0], int_vars[opcode->operand1], int_vars[opcode->operand2]);
505 15           break;
506             }
507             case SPVM_OPCODE_C_ID_LEFT_SHIFT_LONG: {
508 3           SPVM_IMPLEMENT_LEFT_SHIFT_LONG(long_vars[opcode->operand0], long_vars[opcode->operand1], int_vars[opcode->operand2]);
509 3           break;
510             }
511             case SPVM_OPCODE_C_ID_RIGHT_ARITHMETIC_SHIFT_INT: {
512 10           SPVM_IMPLEMENT_RIGHT_ARITHMETIC_SHIFT_INT(int_vars[opcode->operand0], int_vars[opcode->operand1], int_vars[opcode->operand2]);
513 10           break;
514             }
515             case SPVM_OPCODE_C_ID_RIGHT_ARITHMETIC_SHIFT_LONG: {
516 4           SPVM_IMPLEMENT_RIGHT_ARITHMETIC_SHIFT_LONG(long_vars[opcode->operand0], long_vars[opcode->operand1], int_vars[opcode->operand2]);
517 4           break;
518             }
519             case SPVM_OPCODE_C_ID_RIGHT_LOGICAL_SHIFT_INT: {
520 1           SPVM_IMPLEMENT_RIGHT_LOGICAL_SHIFT_INT(int_vars[opcode->operand0], int_vars[opcode->operand1], int_vars[opcode->operand2]);
521 1           break;
522             }
523             case SPVM_OPCODE_C_ID_RIGHT_LOGICAL_SHIFT_LONG: {
524 1           SPVM_IMPLEMENT_RIGHT_LOGICAL_SHIFT_LONG(long_vars[opcode->operand0], long_vars[opcode->operand1], int_vars[opcode->operand2]);
525 1           break;
526             }
527             case SPVM_OPCODE_C_ID_BIT_AND_INT: {
528 20           SPVM_IMPLEMENT_BIT_AND_INT(int_vars[opcode->operand0], int_vars[opcode->operand1], int_vars[opcode->operand2]);
529 20           break;
530             }
531             case SPVM_OPCODE_C_ID_BIT_AND_LONG: {
532 1           SPVM_IMPLEMENT_BIT_AND_LONG(long_vars[opcode->operand0], long_vars[opcode->operand1], long_vars[opcode->operand2]);
533 1           break;
534             }
535             case SPVM_OPCODE_C_ID_BIT_OR_INT: {
536 15           SPVM_IMPLEMENT_BIT_OR_INT(int_vars[opcode->operand0], int_vars[opcode->operand1], int_vars[opcode->operand2]);
537 15           break;
538             }
539             case SPVM_OPCODE_C_ID_BIT_OR_LONG: {
540 1           SPVM_IMPLEMENT_BIT_OR_LONG(long_vars[opcode->operand0], long_vars[opcode->operand1], long_vars[opcode->operand2]);
541 1           break;
542             }
543             case SPVM_OPCODE_C_ID_BIT_XOR_INT: {
544 15           SPVM_IMPLEMENT_BIT_XOR_INT(int_vars[opcode->operand0], int_vars[opcode->operand1], int_vars[opcode->operand2]);
545 15           break;
546             }
547             case SPVM_OPCODE_C_ID_BIT_XOR_LONG: {
548 1           SPVM_IMPLEMENT_BIT_XOR_LONG(long_vars[opcode->operand0], long_vars[opcode->operand1], long_vars[opcode->operand2]);
549 1           break;
550             }
551             case SPVM_OPCODE_C_ID_BIT_NOT_INT: {
552 10           SPVM_IMPLEMENT_BIT_NOT_INT(int_vars[opcode->operand0], int_vars[opcode->operand1]);
553 10           break;
554             }
555             case SPVM_OPCODE_C_ID_BIT_NOT_LONG: {
556 3           SPVM_IMPLEMENT_BIT_NOT_LONG(long_vars[opcode->operand0], long_vars[opcode->operand1]);
557 3           break;
558             }
559             case SPVM_OPCODE_C_ID_NEGATE_INT: {
560 14           SPVM_IMPLEMENT_NEGATE_INT(int_vars[opcode->operand0], int_vars[opcode->operand1]);
561 14           break;
562             }
563             case SPVM_OPCODE_C_ID_NEGATE_LONG: {
564 7           SPVM_IMPLEMENT_NEGATE_LONG(long_vars[opcode->operand0], long_vars[opcode->operand1]);
565 7           break;
566             }
567             case SPVM_OPCODE_C_ID_NEGATE_FLOAT: {
568 3           SPVM_IMPLEMENT_NEGATE_FLOAT(float_vars[opcode->operand0], float_vars[opcode->operand1]);
569 3           break;
570             }
571             case SPVM_OPCODE_C_ID_NEGATE_DOUBLE: {
572 3           SPVM_IMPLEMENT_NEGATE_DOUBLE(double_vars[opcode->operand0], double_vars[opcode->operand1]);
573 3           break;
574             }
575             case SPVM_OPCODE_C_ID_CONCAT: {
576 695           SPVM_IMPLEMENT_CONCAT(env, stack, &object_vars[opcode->operand0], object_vars[opcode->operand1], object_vars[opcode->operand2], &error_id);
577 695           break;
578             }
579             case SPVM_OPCODE_C_ID_BOOL_CONVERSION_INT: {
580 1537983           SPVM_IMPLEMENT_BOOL_CONVERSION_INT(int_vars[0], int_vars[opcode->operand1]);
581 1537983           break;
582             }
583             case SPVM_OPCODE_C_ID_BOOL_CONVERSION_LONG: {
584 8           SPVM_IMPLEMENT_BOOL_CONVERSION_LONG(int_vars[0], long_vars[opcode->operand1]);
585 8           break;
586             }
587             case SPVM_OPCODE_C_ID_BOOL_CONVERSION_FLOAT: {
588 8           SPVM_IMPLEMENT_BOOL_CONVERSION_FLOAT(int_vars[0], float_vars[opcode->operand1]);
589 8           break;
590             }
591             case SPVM_OPCODE_C_ID_BOOL_CONVERSION_DOUBLE: {
592 45           SPVM_IMPLEMENT_BOOL_CONVERSION_DOUBLE(int_vars[0], double_vars[opcode->operand1]);
593 45           break;
594             }
595             case SPVM_OPCODE_C_ID_BOOL_CONVERSION_OBJECT: {
596 76995           SPVM_IMPLEMENT_BOOL_CONVERSION_OBJECT(int_vars[0], object_vars[opcode->operand1]);
597 76995           break;
598             }
599             case SPVM_OPCODE_C_ID_BOOL_CONVERSION_REF: {
600 1           SPVM_IMPLEMENT_BOOL_CONVERSION_REF(int_vars[0], ref_vars[opcode->operand1]);
601 1           break;
602             }
603             case SPVM_OPCODE_C_ID_BOOL_CONVERSION_BOOL_OBJECT: {
604 14           SPVM_IMPLEMENT_BOOL_CONVERSION_BOOL_OBJECT(env, stack, int_vars[0], object_vars[opcode->operand1]);
605 14           break;
606             }
607             case SPVM_OPCODE_C_ID_EQ_INT: {
608 10254           SPVM_IMPLEMENT_EQ_INT(int_vars[0], int_vars[opcode->operand1], int_vars[opcode->operand2]);
609 10254           break;
610             }
611             case SPVM_OPCODE_C_ID_EQ_LONG: {
612 598           SPVM_IMPLEMENT_EQ_LONG(int_vars[0], long_vars[opcode->operand1], long_vars[opcode->operand2]);
613 598           break;
614             }
615             case SPVM_OPCODE_C_ID_EQ_FLOAT: {
616 514           SPVM_IMPLEMENT_EQ_FLOAT(int_vars[0], float_vars[opcode->operand1], float_vars[opcode->operand2]);
617 514           break;
618             }
619             case SPVM_OPCODE_C_ID_EQ_DOUBLE: {
620 580           SPVM_IMPLEMENT_EQ_DOUBLE(int_vars[0], double_vars[opcode->operand1], double_vars[opcode->operand2]);
621 580           break;
622             }
623             case SPVM_OPCODE_C_ID_EQ_OBJECT: {
624 195           SPVM_IMPLEMENT_EQ_OBJECT(int_vars[0], object_vars[opcode->operand1], object_vars[opcode->operand2]);
625 195           break;
626             }
627             case SPVM_OPCODE_C_ID_EQ_REF: {
628 0           SPVM_IMPLEMENT_EQ_REF(int_vars[0], ref_vars[opcode->operand1], ref_vars[opcode->operand2]);
629 0           break;
630             }
631             case SPVM_OPCODE_C_ID_NE_INT: {
632 70           SPVM_IMPLEMENT_NE_INT(int_vars[0], int_vars[opcode->operand1], int_vars[opcode->operand2]);
633 70           break;
634             }
635             case SPVM_OPCODE_C_ID_NE_LONG: {
636 2           SPVM_IMPLEMENT_NE_LONG(int_vars[0], long_vars[opcode->operand1], long_vars[opcode->operand2]);
637 2           break;
638             }
639             case SPVM_OPCODE_C_ID_NE_FLOAT: {
640 2           SPVM_IMPLEMENT_NE_FLOAT(int_vars[0], float_vars[opcode->operand1], float_vars[opcode->operand2]);
641 2           break;
642             }
643             case SPVM_OPCODE_C_ID_NE_DOUBLE: {
644 2           SPVM_IMPLEMENT_NE_DOUBLE(int_vars[0], double_vars[opcode->operand1], double_vars[opcode->operand2]);
645 2           break;
646             }
647             case SPVM_OPCODE_C_ID_NE_OBJECT: {
648 13           SPVM_IMPLEMENT_NE_OBJECT(int_vars[0], object_vars[opcode->operand1], object_vars[opcode->operand2]);
649 13           break;
650             }
651             case SPVM_OPCODE_C_ID_NE_REF: {
652 2           SPVM_IMPLEMENT_NE_REF(int_vars[0], ref_vars[opcode->operand1], ref_vars[opcode->operand2]);
653 2           break;
654             }
655             case SPVM_OPCODE_C_ID_GT_INT: {
656 59106           SPVM_IMPLEMENT_GT_INT(int_vars[0], int_vars[opcode->operand1], int_vars[opcode->operand2]);
657 59106           break;
658             }
659             case SPVM_OPCODE_C_ID_GT_LONG: {
660 11           SPVM_IMPLEMENT_GT_LONG(int_vars[0], long_vars[opcode->operand1], long_vars[opcode->operand2]);
661 11           break;
662             }
663             case SPVM_OPCODE_C_ID_GT_FLOAT: {
664 3           SPVM_IMPLEMENT_GT_FLOAT(int_vars[0], float_vars[opcode->operand1], float_vars[opcode->operand2]);
665 3           break;
666             }
667             case SPVM_OPCODE_C_ID_GT_DOUBLE: {
668 192           SPVM_IMPLEMENT_GT_DOUBLE(int_vars[0], double_vars[opcode->operand1], double_vars[opcode->operand2]);
669 192           break;
670             }
671             case SPVM_OPCODE_C_ID_GE_INT: {
672 105992           SPVM_IMPLEMENT_GE_INT(int_vars[0], int_vars[opcode->operand1], int_vars[opcode->operand2]);
673 105992           break;
674             }
675             case SPVM_OPCODE_C_ID_GE_LONG: {
676 3           SPVM_IMPLEMENT_GE_LONG(int_vars[0], long_vars[opcode->operand1], long_vars[opcode->operand2]);
677 3           break;
678             }
679             case SPVM_OPCODE_C_ID_GE_FLOAT: {
680 3           SPVM_IMPLEMENT_GE_FLOAT(int_vars[0], float_vars[opcode->operand1], float_vars[opcode->operand2]);
681 3           break;
682             }
683             case SPVM_OPCODE_C_ID_GE_DOUBLE: {
684 100003           SPVM_IMPLEMENT_GE_DOUBLE(int_vars[0], double_vars[opcode->operand1], double_vars[opcode->operand2]);
685 100003           break;
686             }
687             case SPVM_OPCODE_C_ID_LT_INT: {
688 699747           SPVM_IMPLEMENT_LT_INT(int_vars[0], int_vars[opcode->operand1], int_vars[opcode->operand2]);
689 699747           break;
690             }
691             case SPVM_OPCODE_C_ID_LT_LONG: {
692 3           SPVM_IMPLEMENT_LT_LONG(int_vars[0], long_vars[opcode->operand1], long_vars[opcode->operand2]);
693 3           break;
694             }
695             case SPVM_OPCODE_C_ID_LT_FLOAT: {
696 3           SPVM_IMPLEMENT_LT_FLOAT(int_vars[0], float_vars[opcode->operand1], float_vars[opcode->operand2]);
697 3           break;
698             }
699             case SPVM_OPCODE_C_ID_LT_DOUBLE: {
700 100003           SPVM_IMPLEMENT_LT_DOUBLE(int_vars[0], double_vars[opcode->operand1], double_vars[opcode->operand2]);
701 100003           break;
702             }
703             case SPVM_OPCODE_C_ID_LE_INT: {
704 46930           SPVM_IMPLEMENT_LE_INT(int_vars[0], int_vars[opcode->operand1], int_vars[opcode->operand2]);
705 46930           break;
706             }
707             case SPVM_OPCODE_C_ID_LE_LONG: {
708 3           SPVM_IMPLEMENT_LE_LONG(int_vars[0], long_vars[opcode->operand1], long_vars[opcode->operand2]);
709 3           break;
710             }
711             case SPVM_OPCODE_C_ID_LE_FLOAT: {
712 3           SPVM_IMPLEMENT_LE_FLOAT(int_vars[0], float_vars[opcode->operand1], float_vars[opcode->operand2]);
713 3           break;
714             }
715             case SPVM_OPCODE_C_ID_LE_DOUBLE: {
716 3           SPVM_IMPLEMENT_LE_DOUBLE(int_vars[0], double_vars[opcode->operand1], double_vars[opcode->operand2]);
717 3           break;
718             }
719             case SPVM_OPCODE_C_ID_CMP_INT: {
720 245 100         SPVM_IMPLEMENT_CMP_INT(int_vars[0], int_vars[opcode->operand1], int_vars[opcode->operand2]);
    100          
721 245           break;
722             }
723             case SPVM_OPCODE_C_ID_CMP_LONG: {
724 74 100         SPVM_IMPLEMENT_CMP_LONG(int_vars[0], long_vars[opcode->operand1], long_vars[opcode->operand2]);
    100          
725 74           break;
726             }
727             case SPVM_OPCODE_C_ID_CMP_FLOAT: {
728 76 100         SPVM_IMPLEMENT_CMP_FLOAT(int_vars[0], float_vars[opcode->operand1], float_vars[opcode->operand2]);
    100          
729 76           break;
730             }
731             case SPVM_OPCODE_C_ID_CMP_DOUBLE: {
732 74 100         SPVM_IMPLEMENT_CMP_DOUBLE(int_vars[0], double_vars[opcode->operand1], double_vars[opcode->operand2]);
    100          
733 74           break;
734             }
735             case SPVM_OPCODE_C_ID_IS_UNDEF: {
736 87           SPVM_IMPLEMENT_IS_UNDEF(int_vars[0], object_vars[opcode->operand1]);
737 87           break;
738             }
739             case SPVM_OPCODE_C_ID_IS_NOT_UNDEF: {
740 3           SPVM_IMPLEMENT_IS_NOT_UNDEF(int_vars[0], object_vars[opcode->operand1]);
741 3           break;
742             }
743             case SPVM_OPCODE_C_ID_STRING_EQ: {
744 672           SPVM_IMPLEMENT_STRING_EQ(env, stack, &int_vars[0], object_vars[opcode->operand1], object_vars[opcode->operand2]);
745 672           break;
746             }
747             case SPVM_OPCODE_C_ID_STRING_NE: {
748 11           SPVM_IMPLEMENT_STRING_NE(env, stack, &int_vars[0], object_vars[opcode->operand1], object_vars[opcode->operand2]);
749 11           break;
750             }
751             case SPVM_OPCODE_C_ID_STRING_GT: {
752 11           SPVM_IMPLEMENT_STRING_GT(env, stack, &int_vars[0], object_vars[opcode->operand1], object_vars[opcode->operand2]);
753 11           break;
754             }
755             case SPVM_OPCODE_C_ID_STRING_GE: {
756 11           SPVM_IMPLEMENT_STRING_GE(env, stack, &int_vars[0], object_vars[opcode->operand1], object_vars[opcode->operand2]);
757 11           break;
758             }
759             case SPVM_OPCODE_C_ID_STRING_LT: {
760 1           SPVM_IMPLEMENT_STRING_LT(env, stack, &int_vars[0], object_vars[opcode->operand1], object_vars[opcode->operand2]);
761 1           break;
762             }
763             case SPVM_OPCODE_C_ID_STRING_LE: {
764 11           SPVM_IMPLEMENT_STRING_LE(env, stack, &int_vars[0], object_vars[opcode->operand1], object_vars[opcode->operand2]);
765 11           break;
766             }
767             case SPVM_OPCODE_C_ID_STRING_CMP: {
768 124           SPVM_IMPLEMENT_STRING_CMP(env, stack, &int_vars[0], object_vars[opcode->operand1], object_vars[opcode->operand2]);
769 124           break;
770             }
771             case SPVM_OPCODE_C_ID_NEW_OBJECT: {
772 35330           int32_t basic_type_id = opcode->operand1;
773            
774 35330           SPVM_RUNTIME_BASIC_TYPE* basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(env->runtime, basic_type_id);
775            
776 35330           SPVM_IMPLEMENT_NEW_OBJECT(env, stack, &object_vars[opcode->operand0], basic_type, &error_id);
777 35330           break;
778             }
779             case SPVM_OPCODE_C_ID_NEW_OBJECT_ARRAY: {
780 35666           int32_t basic_type_id = opcode->operand1;
781 35666           int32_t length = int_vars[opcode->operand2];
782            
783 35666           SPVM_RUNTIME_BASIC_TYPE* basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(env->runtime, basic_type_id);
784            
785 35666           SPVM_IMPLEMENT_NEW_OBJECT_ARRAY(env, stack, &object_vars[opcode->operand0], basic_type, length, &error_id);
786 35666           break;
787             }
788             case SPVM_OPCODE_C_ID_NEW_MULDIM_ARRAY: {
789 25           int32_t basic_type_id = opcode->operand1;
790 25           int32_t type_dimension = opcode->operand3;
791 25           int32_t length = int_vars[opcode->operand2];
792            
793 25           SPVM_RUNTIME_BASIC_TYPE* basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(env->runtime, basic_type_id);
794            
795 25           SPVM_IMPLEMENT_NEW_MULDIM_ARRAY(env, stack, &object_vars[opcode->operand0], basic_type, type_dimension, length, &error_id);
796 25           break;
797             }
798             case SPVM_OPCODE_C_ID_NEW_MULNUM_ARRAY: {
799 85           int32_t basic_type_id = opcode->operand1;
800 85           int32_t length = int_vars[opcode->operand2];
801            
802 85           SPVM_RUNTIME_BASIC_TYPE* basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(env->runtime, basic_type_id);
803            
804 85           SPVM_IMPLEMENT_NEW_MULNUM_ARRAY(env, stack, &object_vars[opcode->operand0], basic_type, length, &error_id);
805 85           break;
806             }
807             case SPVM_OPCODE_C_ID_NEW_BYTE_ARRAY: {
808 479           int32_t length = int_vars[opcode->operand1];
809 479           SPVM_IMPLEMENT_NEW_BYTE_ARRAY(env, stack, &object_vars[opcode->operand0], length, &error_id);
810 479           break;
811             }
812             case SPVM_OPCODE_C_ID_NEW_SHORT_ARRAY: {
813 441           int32_t length = int_vars[opcode->operand1];
814 441           SPVM_IMPLEMENT_NEW_SHORT_ARRAY(env, stack, &object_vars[opcode->operand0], length, &error_id);
815 441           break;
816             }
817             case SPVM_OPCODE_C_ID_NEW_INT_ARRAY: {
818 529           int32_t length = int_vars[opcode->operand1];
819 529           SPVM_IMPLEMENT_NEW_INT_ARRAY(env, stack, &object_vars[opcode->operand0], length, &error_id);
820 529           break;
821             }
822             case SPVM_OPCODE_C_ID_NEW_LONG_ARRAY: {
823 434           int32_t length = int_vars[opcode->operand1];
824 434           SPVM_IMPLEMENT_NEW_LONG_ARRAY(env, stack, &object_vars[opcode->operand0], length, &error_id);
825 434           break;
826             }
827             case SPVM_OPCODE_C_ID_NEW_FLOAT_ARRAY: {
828 438           int32_t length = int_vars[opcode->operand1];
829 438           SPVM_IMPLEMENT_NEW_FLOAT_ARRAY(env, stack, &object_vars[opcode->operand0], length, &error_id);
830 438           break;
831             }
832             case SPVM_OPCODE_C_ID_NEW_DOUBLE_ARRAY: {
833 445           int32_t length = int_vars[opcode->operand1];
834 445           SPVM_IMPLEMENT_NEW_DOUBLE_ARRAY(env, stack, &object_vars[opcode->operand0], length, &error_id);
835 445           break;
836             }
837             case SPVM_OPCODE_C_ID_NEW_STRING: {
838 4585           int32_t constant_string_index = opcode->operand1;
839 4585           SPVM_RUNTIME_STRING* constant_string = ¤t_basic_type->constant_strings[constant_string_index];
840 4585           const char* constant_string_value = constant_string->value;
841 4585           int32_t constant_string_length = constant_string->length;
842 4585           SPVM_IMPLEMENT_NEW_STRING(env, stack, &object_vars[opcode->operand0], constant_string_value, constant_string_length, &error_id);
843 4585           break;
844             }
845             case SPVM_OPCODE_C_ID_NEW_STRING_LEN: {
846 2221           int32_t length = int_vars[opcode->operand1];
847 2221           SPVM_IMPLEMENT_NEW_STRING_LEN(env, stack, &object_vars[opcode->operand0], length, &error_id);
848 2221           break;
849             }
850             case SPVM_OPCODE_C_ID_IS_READ_ONLY: {
851 4           SPVM_IMPLEMENT_IS_READ_ONLY(env, stack, int_vars[0], object_vars[opcode->operand1]);
852 4           break;
853             }
854             case SPVM_OPCODE_C_ID_MAKE_READ_ONLY: {
855 25           SPVM_IMPLEMENT_MAKE_READ_ONLY(env, stack, object_vars[opcode->operand0]);
856 25           break;
857             }
858             case SPVM_OPCODE_C_ID_GET_ARRAY_ELEMENT_BYTE: {
859 3569           void* array = object_vars[opcode->operand1];
860 3569           int32_t index = int_vars[opcode->operand2];
861 3569           SPVM_IMPLEMENT_GET_ARRAY_ELEMENT_BYTE(env, stack, &byte_vars[opcode->operand0], array, index, &error_id, object_data_offset, object_length_offset);
862 3569           break;
863             }
864             case SPVM_OPCODE_C_ID_GET_ARRAY_ELEMENT_SHORT: {
865 559           void* array = object_vars[opcode->operand1];
866 559           int32_t index = int_vars[opcode->operand2];
867 559           SPVM_IMPLEMENT_GET_ARRAY_ELEMENT_SHORT(env, stack, &short_vars[opcode->operand0], array, index, &error_id, object_data_offset, object_length_offset);
868 559           break;
869             }
870             case SPVM_OPCODE_C_ID_GET_ARRAY_ELEMENT_INT: {
871 617           void* array = object_vars[opcode->operand1];
872 617           int32_t index = int_vars[opcode->operand2];
873 617           SPVM_IMPLEMENT_GET_ARRAY_ELEMENT_INT(env, stack, &int_vars[opcode->operand0], array, index, &error_id, object_data_offset, object_length_offset);
874 617           break;
875             }
876             case SPVM_OPCODE_C_ID_GET_ARRAY_ELEMENT_LONG: {
877 568           void* array = object_vars[opcode->operand1];
878 568           int32_t index = int_vars[opcode->operand2];
879 568           SPVM_IMPLEMENT_GET_ARRAY_ELEMENT_LONG(env, stack, &long_vars[opcode->operand0], array, index, &error_id, object_data_offset, object_length_offset);
880 568           break;
881             }
882             case SPVM_OPCODE_C_ID_GET_ARRAY_ELEMENT_FLOAT: {
883 559           void* array = object_vars[opcode->operand1];
884 559           int32_t index = int_vars[opcode->operand2];
885 559           SPVM_IMPLEMENT_GET_ARRAY_ELEMENT_FLOAT(env, stack, &float_vars[opcode->operand0], array, index, &error_id, object_data_offset, object_length_offset);
886 559           break;
887             }
888             case SPVM_OPCODE_C_ID_GET_ARRAY_ELEMENT_DOUBLE: {
889 559           void* array = object_vars[opcode->operand1];
890 559           int32_t index = int_vars[opcode->operand2];
891 559           SPVM_IMPLEMENT_GET_ARRAY_ELEMENT_DOUBLE(env, stack, &double_vars[opcode->operand0], array, index, &error_id, object_data_offset, object_length_offset);
892 559           break;
893             }
894             case SPVM_OPCODE_C_ID_GET_ARRAY_ELEMENT_OBJECT: {
895 73232           void* array = object_vars[opcode->operand1];
896 73232           int32_t index = int_vars[opcode->operand2];
897 73232           SPVM_IMPLEMENT_GET_ARRAY_ELEMENT_OBJECT(env, stack, &object_vars[opcode->operand0], array, index, &error_id, object_data_offset, object_length_offset);
898 73232           break;
899             }
900             case SPVM_OPCODE_C_ID_SET_ARRAY_ELEMENT_BYTE: {
901 4703           void* array = object_vars[opcode->operand0];
902 4703           int32_t index = int_vars[opcode->operand1];
903 4703           SPVM_IMPLEMENT_SET_ARRAY_ELEMENT_BYTE(env, stack, array, index, byte_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
904 4703           break;
905             }
906             case SPVM_OPCODE_C_ID_SET_ARRAY_ELEMENT_SHORT: {
907 1094           void* array = object_vars[opcode->operand0];
908 1094           int32_t index = int_vars[opcode->operand1];
909 1094           SPVM_IMPLEMENT_SET_ARRAY_ELEMENT_SHORT(env, stack, array, index, short_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
910 1094           break;
911             }
912             case SPVM_OPCODE_C_ID_SET_ARRAY_ELEMENT_INT: {
913 301228           void* array = object_vars[opcode->operand0];
914 301228           int32_t index = int_vars[opcode->operand1];
915 301228           SPVM_IMPLEMENT_SET_ARRAY_ELEMENT_INT(env, stack, array, index, int_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
916 301228           break;
917             }
918             case SPVM_OPCODE_C_ID_SET_ARRAY_ELEMENT_LONG: {
919 1087           void* array = object_vars[opcode->operand0];
920 1087           int32_t index = int_vars[opcode->operand1];
921 1087           SPVM_IMPLEMENT_SET_ARRAY_ELEMENT_LONG(env, stack, array, index, long_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
922 1087           break;
923             }
924             case SPVM_OPCODE_C_ID_SET_ARRAY_ELEMENT_FLOAT: {
925 1083           void* array = object_vars[opcode->operand0];
926 1083           int32_t index = int_vars[opcode->operand1];
927 1083           SPVM_IMPLEMENT_SET_ARRAY_ELEMENT_FLOAT(env, stack, array, index, float_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
928 1083           break;
929             }
930             case SPVM_OPCODE_C_ID_SET_ARRAY_ELEMENT_DOUBLE: {
931 1108           void* array = object_vars[opcode->operand0];
932 1108           int32_t index = int_vars[opcode->operand1];
933 1108           SPVM_IMPLEMENT_SET_ARRAY_ELEMENT_DOUBLE(env, stack, array, index, double_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
934 1108           break;
935             }
936             case SPVM_OPCODE_C_ID_SET_ARRAY_ELEMENT_OBJECT: {
937 33802           void* array = object_vars[opcode->operand0];
938 33802           int32_t index = int_vars[opcode->operand1];
939 33802           SPVM_IMPLEMENT_SET_ARRAY_ELEMENT_OBJECT(env, stack, array, index, object_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
940 33802           break;
941             }
942             case SPVM_OPCODE_C_ID_SET_ARRAY_ELEMENT_OBJECT_CHECK_TYPE: {
943 72606           void* array = object_vars[opcode->operand0];
944 72606           int32_t index = int_vars[opcode->operand1];
945 72606           SPVM_IMPLEMENT_SET_ARRAY_ELEMENT_OBJECT_CHECK_TYPE(env, stack, array, index, object_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
946 72606           break;
947             }
948             case SPVM_OPCODE_C_ID_SET_ARRAY_ELEMENT_UNDEF: {
949 103           void* array = object_vars[opcode->operand0];
950 103           int32_t index = int_vars[opcode->operand1];
951 103           SPVM_IMPLEMENT_SET_ARRAY_ELEMENT_UNDEF(env, stack, array, index, &error_id, object_data_offset, object_length_offset);
952 103           break;
953             }
954             case SPVM_OPCODE_C_ID_ARRAY_LENGTH: {
955 43464           SPVM_IMPLEMENT_ARRAY_LENGTH(env, stack, &int_vars[opcode->operand0], object_vars[opcode->operand1], &error_id, object_length_offset);
956 43464           break;
957             }
958             case SPVM_OPCODE_C_ID_GET_FIELD_BYTE: {
959 62           void* object = object_vars[opcode->operand1];
960 62           int32_t field_current_basic_type_id = opcode->operand2;
961 62           int32_t field_index = (uint16_t)opcode->operand3;
962            
963 62           SPVM_RUNTIME_BASIC_TYPE* field_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, field_current_basic_type_id);
964 62           SPVM_RUNTIME_FIELD* field = SPVM_API_BASIC_TYPE_get_field_by_index(env->runtime, field_current_basic_type, field_index);
965 62           int32_t field_offset = field->offset;
966            
967 62           SPVM_IMPLEMENT_GET_FIELD_BYTE(env, stack, &byte_vars[opcode->operand0], object, field_offset, &error_id, object_data_offset);
968 62           break;
969             }
970             case SPVM_OPCODE_C_ID_GET_FIELD_SHORT: {
971 37           void* object = object_vars[opcode->operand1];
972 37           int32_t field_current_basic_type_id = opcode->operand2;
973 37           int32_t field_index = (uint16_t)opcode->operand3;
974            
975 37           SPVM_RUNTIME_BASIC_TYPE* field_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, field_current_basic_type_id);
976 37           SPVM_RUNTIME_FIELD* field = SPVM_API_BASIC_TYPE_get_field_by_index(env->runtime, field_current_basic_type, field_index);
977 37           int32_t field_offset = field->offset;
978            
979 37           SPVM_IMPLEMENT_GET_FIELD_SHORT(env, stack, &short_vars[opcode->operand0], object, field_offset, &error_id, object_data_offset);
980 37           break;
981             }
982             case SPVM_OPCODE_C_ID_GET_FIELD_INT: {
983 115262           void* object = object_vars[opcode->operand1];
984 115262           int32_t field_current_basic_type_id = opcode->operand2;
985 115262           int32_t field_index = (uint16_t)opcode->operand3;
986            
987 115262           SPVM_RUNTIME_BASIC_TYPE* field_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, field_current_basic_type_id);
988 115262           SPVM_RUNTIME_FIELD* field = SPVM_API_BASIC_TYPE_get_field_by_index(env->runtime, field_current_basic_type, field_index);
989 115262           int32_t field_offset = field->offset;
990            
991 115262           SPVM_IMPLEMENT_GET_FIELD_INT(env, stack, &int_vars[opcode->operand0], object, field_offset, &error_id, object_data_offset);
992            
993 115262           break;
994             }
995             case SPVM_OPCODE_C_ID_GET_FIELD_LONG: {
996 39           void* object = object_vars[opcode->operand1];
997 39           int32_t field_current_basic_type_id = opcode->operand2;
998 39           int32_t field_index = (uint16_t)opcode->operand3;
999            
1000 39           SPVM_RUNTIME_BASIC_TYPE* field_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, field_current_basic_type_id);
1001 39           SPVM_RUNTIME_FIELD* field = SPVM_API_BASIC_TYPE_get_field_by_index(env->runtime, field_current_basic_type, field_index);
1002 39           int32_t field_offset = field->offset;
1003            
1004 39           SPVM_IMPLEMENT_GET_FIELD_LONG(env, stack, &long_vars[opcode->operand0], object, field_offset, &error_id, object_data_offset);
1005 39           break;
1006             }
1007             case SPVM_OPCODE_C_ID_GET_FIELD_FLOAT: {
1008 65           void* object = object_vars[opcode->operand1];
1009 65           int32_t field_current_basic_type_id = opcode->operand2;
1010 65           int32_t field_index = (uint16_t)opcode->operand3;
1011            
1012 65           SPVM_RUNTIME_BASIC_TYPE* field_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, field_current_basic_type_id);
1013 65           SPVM_RUNTIME_FIELD* field = SPVM_API_BASIC_TYPE_get_field_by_index(env->runtime, field_current_basic_type, field_index);
1014 65           int32_t field_offset = field->offset;
1015            
1016 65           SPVM_IMPLEMENT_GET_FIELD_FLOAT(env, stack, &float_vars[opcode->operand0], object, field_offset, &error_id, object_data_offset);
1017 65           break;
1018             }
1019             case SPVM_OPCODE_C_ID_GET_FIELD_DOUBLE: {
1020 93           void* object = object_vars[opcode->operand1];
1021 93           int32_t field_current_basic_type_id = opcode->operand2;
1022 93           int32_t field_index = (uint16_t)opcode->operand3;
1023            
1024 93           SPVM_RUNTIME_BASIC_TYPE* field_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, field_current_basic_type_id);
1025 93           SPVM_RUNTIME_FIELD* field = SPVM_API_BASIC_TYPE_get_field_by_index(env->runtime, field_current_basic_type, field_index);
1026 93           int32_t field_offset = field->offset;
1027            
1028 93           SPVM_IMPLEMENT_GET_FIELD_DOUBLE(env, stack, &double_vars[opcode->operand0], object, field_offset, &error_id, object_data_offset);
1029 93           break;
1030             }
1031             case SPVM_OPCODE_C_ID_GET_FIELD_OBJECT: {
1032 68940           void* object = object_vars[opcode->operand1];
1033 68940           int32_t field_current_basic_type_id = opcode->operand2;
1034 68940           int32_t field_index = (uint16_t)opcode->operand3;
1035            
1036 68940           SPVM_RUNTIME_BASIC_TYPE* field_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, field_current_basic_type_id);
1037 68940           SPVM_RUNTIME_FIELD* field = SPVM_API_BASIC_TYPE_get_field_by_index(env->runtime, field_current_basic_type, field_index);
1038 68940           int32_t field_offset = field->offset;
1039            
1040 68940           SPVM_IMPLEMENT_GET_FIELD_OBJECT(env, stack, &object_vars[opcode->operand0], object, field_offset, &error_id, object_data_offset);
1041 68940           break;
1042             }
1043             case SPVM_OPCODE_C_ID_SET_FIELD_BYTE: {
1044 69           void* object = object_vars[opcode->operand0];
1045 69           int32_t field_current_basic_type_id = opcode->operand2;
1046 69           int32_t field_index = (uint16_t)opcode->operand3;
1047            
1048 69           SPVM_RUNTIME_BASIC_TYPE* field_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, field_current_basic_type_id);
1049 69           SPVM_RUNTIME_FIELD* field = SPVM_API_BASIC_TYPE_get_field_by_index(env->runtime, field_current_basic_type, field_index);
1050 69           int32_t field_offset = field->offset;
1051            
1052 69           SPVM_IMPLEMENT_SET_FIELD_BYTE(env, stack, object, field_offset, byte_vars[opcode->operand1], &error_id, object_data_offset);
1053 69           break;
1054             }
1055             case SPVM_OPCODE_C_ID_SET_FIELD_SHORT: {
1056 51           void* object = object_vars[opcode->operand0];
1057 51           int32_t field_current_basic_type_id = opcode->operand2;
1058 51           int32_t field_index = (uint16_t)opcode->operand3;
1059            
1060 51           SPVM_RUNTIME_BASIC_TYPE* field_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, field_current_basic_type_id);
1061 51           SPVM_RUNTIME_FIELD* field = SPVM_API_BASIC_TYPE_get_field_by_index(env->runtime, field_current_basic_type, field_index);
1062 51           int32_t field_offset = field->offset;
1063            
1064 51           SPVM_IMPLEMENT_SET_FIELD_SHORT(env, stack, object, field_offset, short_vars[opcode->operand1], &error_id, object_data_offset);
1065 51           break;
1066             }
1067             case SPVM_OPCODE_C_ID_SET_FIELD_INT: {
1068 97898           void* object = object_vars[opcode->operand0];
1069 97898           int32_t field_current_basic_type_id = opcode->operand2;
1070 97898           int32_t field_index = (uint16_t)opcode->operand3;
1071            
1072 97898           SPVM_RUNTIME_BASIC_TYPE* field_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, field_current_basic_type_id);
1073 97898           SPVM_RUNTIME_FIELD* field = SPVM_API_BASIC_TYPE_get_field_by_index(env->runtime, field_current_basic_type, field_index);
1074 97898           int32_t field_offset = field->offset;
1075            
1076 97898           SPVM_IMPLEMENT_SET_FIELD_INT(env, stack, object, field_offset, int_vars[opcode->operand1], &error_id, object_data_offset);
1077 97898           break;
1078             }
1079             case SPVM_OPCODE_C_ID_SET_FIELD_LONG: {
1080 207           void* object = object_vars[opcode->operand0];
1081 207           int32_t field_current_basic_type_id = opcode->operand2;
1082 207           int32_t field_index = (uint16_t)opcode->operand3;
1083            
1084 207           SPVM_RUNTIME_BASIC_TYPE* field_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, field_current_basic_type_id);
1085 207           SPVM_RUNTIME_FIELD* field = SPVM_API_BASIC_TYPE_get_field_by_index(env->runtime, field_current_basic_type, field_index);
1086 207           int32_t field_offset = field->offset;
1087            
1088 207           SPVM_IMPLEMENT_SET_FIELD_LONG(env, stack, object, field_offset, long_vars[opcode->operand1], &error_id, object_data_offset);
1089 207           break;
1090             }
1091             case SPVM_OPCODE_C_ID_SET_FIELD_FLOAT: {
1092 75           void* object = object_vars[opcode->operand0];
1093 75           int32_t field_current_basic_type_id = opcode->operand2;
1094 75           int32_t field_index = (uint16_t)opcode->operand3;
1095            
1096 75           SPVM_RUNTIME_BASIC_TYPE* field_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, field_current_basic_type_id);
1097 75           SPVM_RUNTIME_FIELD* field = SPVM_API_BASIC_TYPE_get_field_by_index(env->runtime, field_current_basic_type, field_index);
1098 75           int32_t field_offset = field->offset;
1099            
1100 75           SPVM_IMPLEMENT_SET_FIELD_FLOAT(env, stack, object, field_offset, float_vars[opcode->operand1], &error_id, object_data_offset);
1101 75           break;
1102             }
1103             case SPVM_OPCODE_C_ID_SET_FIELD_DOUBLE: {
1104 79           void* object = object_vars[opcode->operand0];
1105 79           int32_t field_current_basic_type_id = opcode->operand2;
1106 79           int32_t field_index = (uint16_t)opcode->operand3;
1107            
1108 79           SPVM_RUNTIME_BASIC_TYPE* field_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, field_current_basic_type_id);
1109 79           SPVM_RUNTIME_FIELD* field = SPVM_API_BASIC_TYPE_get_field_by_index(env->runtime, field_current_basic_type, field_index);
1110 79           int32_t field_offset = field->offset;
1111            
1112 79           SPVM_IMPLEMENT_SET_FIELD_DOUBLE(env, stack, object, field_offset, double_vars[opcode->operand1], &error_id, object_data_offset);
1113 79           break;
1114             }
1115             case SPVM_OPCODE_C_ID_SET_FIELD_OBJECT: {
1116 21517           void* object = object_vars[opcode->operand0];
1117 21517           int32_t field_current_basic_type_id = opcode->operand2;
1118 21517           int32_t field_index = (uint16_t)opcode->operand3;
1119            
1120 21517           SPVM_RUNTIME_BASIC_TYPE* field_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, field_current_basic_type_id);
1121 21517           SPVM_RUNTIME_FIELD* field = SPVM_API_BASIC_TYPE_get_field_by_index(env->runtime, field_current_basic_type, field_index);
1122 21517           int32_t field_offset = field->offset;
1123            
1124 21517           SPVM_IMPLEMENT_SET_FIELD_OBJECT(env, stack, object, field_offset, object_vars[opcode->operand1], &error_id, object_data_offset);
1125 21517           break;
1126             }
1127             case SPVM_OPCODE_C_ID_SET_FIELD_UNDEF: {
1128 6           void* object = object_vars[opcode->operand0];
1129 6           int32_t field_current_basic_type_id = opcode->operand2;
1130 6           int32_t field_index = (uint16_t)opcode->operand3;
1131            
1132 6           SPVM_RUNTIME_BASIC_TYPE* field_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, field_current_basic_type_id);
1133 6           SPVM_RUNTIME_FIELD* field = SPVM_API_BASIC_TYPE_get_field_by_index(env->runtime, field_current_basic_type, field_index);
1134 6           int32_t field_offset = field->offset;
1135            
1136 6           SPVM_IMPLEMENT_SET_FIELD_UNDEF(env, stack, object, field_offset, &error_id, object_data_offset);
1137 6           break;
1138             }
1139             case SPVM_OPCODE_C_ID_WEAKEN_FIELD: {
1140 19           int32_t field_current_basic_type_id = opcode->operand2;
1141 19           int32_t field_index = (uint16_t)opcode->operand3;
1142 19           void* object = object_vars[opcode->operand0];
1143            
1144 19           SPVM_RUNTIME_BASIC_TYPE* field_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, field_current_basic_type_id);
1145 19           SPVM_RUNTIME_FIELD* field = SPVM_API_BASIC_TYPE_get_field_by_index(env->runtime, field_current_basic_type, field_index);
1146 19           int32_t field_offset = field->offset;
1147            
1148 19           SPVM_IMPLEMENT_WEAKEN_FIELD(env, stack, object, field_offset, &error_id, object_data_offset);
1149 19           break;
1150             }
1151             case SPVM_OPCODE_C_ID_UNWEAKEN_FIELD: {
1152 0           int32_t field_current_basic_type_id = opcode->operand2;
1153 0           int32_t field_index = (uint16_t)opcode->operand3;
1154 0           void* object = object_vars[opcode->operand0];
1155            
1156 0           SPVM_RUNTIME_BASIC_TYPE* field_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, field_current_basic_type_id);
1157 0           SPVM_RUNTIME_FIELD* field = SPVM_API_BASIC_TYPE_get_field_by_index(env->runtime, field_current_basic_type, field_index);
1158 0           int32_t field_offset = field->offset;
1159            
1160 0           SPVM_IMPLEMENT_UNWEAKEN_FIELD(env, stack, object, field_offset, &error_id, object_data_offset);
1161 0           break;
1162             }
1163             case SPVM_OPCODE_C_ID_ISWEAK_FIELD: {
1164 2           int32_t field_current_basic_type_id = opcode->operand2;
1165 2           int32_t field_index = (uint16_t)opcode->operand3;
1166 2           void* object = object_vars[opcode->operand1];
1167            
1168 2           SPVM_RUNTIME_BASIC_TYPE* field_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, field_current_basic_type_id);
1169 2           SPVM_RUNTIME_FIELD* field = SPVM_API_BASIC_TYPE_get_field_by_index(env->runtime, field_current_basic_type, field_index);
1170 2           int32_t field_offset = field->offset;
1171            
1172 2           SPVM_IMPLEMENT_ISWEAK_FIELD(env, stack, &int_vars[0], object, field_offset, &error_id, object_data_offset);
1173 2           break;
1174             }
1175             case SPVM_OPCODE_C_ID_GET_CLASS_VAR_BYTE: {
1176 13           int32_t class_var_current_basic_type_id = opcode->operand1;
1177 13           int32_t class_var_index = opcode->operand2;
1178            
1179 13           SPVM_RUNTIME_BASIC_TYPE* class_var_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, class_var_current_basic_type_id);
1180 13           SPVM_RUNTIME_CLASS_VAR* class_var = SPVM_API_BASIC_TYPE_get_class_var_by_index(env->runtime, class_var_current_basic_type, class_var_index);
1181            
1182 13           SPVM_IMPLEMENT_GET_CLASS_VAR_BYTE(env, stack, byte_vars[opcode->operand0], class_var);
1183 13           break;
1184             }
1185             case SPVM_OPCODE_C_ID_GET_CLASS_VAR_SHORT: {
1186 13           int32_t class_var_current_basic_type_id = opcode->operand1;
1187 13           int32_t class_var_index = opcode->operand2;
1188            
1189 13           SPVM_RUNTIME_BASIC_TYPE* class_var_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, class_var_current_basic_type_id);
1190 13           SPVM_RUNTIME_CLASS_VAR* class_var = SPVM_API_BASIC_TYPE_get_class_var_by_index(env->runtime, class_var_current_basic_type, class_var_index);
1191            
1192 13           SPVM_IMPLEMENT_GET_CLASS_VAR_SHORT(env, stack, short_vars[opcode->operand0], class_var);
1193 13           break;
1194             }
1195             case SPVM_OPCODE_C_ID_GET_CLASS_VAR_INT: {
1196 46           int32_t class_var_current_basic_type_id = opcode->operand1;
1197 46           int32_t class_var_index = opcode->operand2;
1198            
1199 46           SPVM_RUNTIME_BASIC_TYPE* class_var_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, class_var_current_basic_type_id);
1200 46           SPVM_RUNTIME_CLASS_VAR* class_var = SPVM_API_BASIC_TYPE_get_class_var_by_index(env->runtime, class_var_current_basic_type, class_var_index);
1201            
1202 46           SPVM_IMPLEMENT_GET_CLASS_VAR_INT(env, stack, int_vars[opcode->operand0], class_var);
1203 46           break;
1204             }
1205             case SPVM_OPCODE_C_ID_GET_CLASS_VAR_LONG: {
1206 20           int32_t class_var_current_basic_type_id = opcode->operand1;
1207 20           int32_t class_var_index = opcode->operand2;
1208            
1209 20           SPVM_RUNTIME_BASIC_TYPE* class_var_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, class_var_current_basic_type_id);
1210 20           SPVM_RUNTIME_CLASS_VAR* class_var = SPVM_API_BASIC_TYPE_get_class_var_by_index(env->runtime, class_var_current_basic_type, class_var_index);
1211            
1212 20           SPVM_IMPLEMENT_GET_CLASS_VAR_LONG(env, stack, long_vars[opcode->operand0], class_var);
1213 20           break;
1214             }
1215             case SPVM_OPCODE_C_ID_GET_CLASS_VAR_FLOAT: {
1216 13           int32_t class_var_current_basic_type_id = opcode->operand1;
1217 13           int32_t class_var_index = opcode->operand2;
1218            
1219 13           SPVM_RUNTIME_BASIC_TYPE* class_var_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, class_var_current_basic_type_id);
1220 13           SPVM_RUNTIME_CLASS_VAR* class_var = SPVM_API_BASIC_TYPE_get_class_var_by_index(env->runtime, class_var_current_basic_type, class_var_index);
1221            
1222 13           SPVM_IMPLEMENT_GET_CLASS_VAR_FLOAT(env, stack, float_vars[opcode->operand0], class_var);
1223 13           break;
1224             }
1225             case SPVM_OPCODE_C_ID_GET_CLASS_VAR_DOUBLE: {
1226 13           int32_t class_var_current_basic_type_id = opcode->operand1;
1227 13           int32_t class_var_index = opcode->operand2;
1228            
1229 13           SPVM_RUNTIME_BASIC_TYPE* class_var_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, class_var_current_basic_type_id);
1230 13           SPVM_RUNTIME_CLASS_VAR* class_var = SPVM_API_BASIC_TYPE_get_class_var_by_index(env->runtime, class_var_current_basic_type, class_var_index);
1231            
1232 13           SPVM_IMPLEMENT_GET_CLASS_VAR_DOUBLE(env, stack, double_vars[opcode->operand0], class_var);
1233 13           break;
1234             }
1235             case SPVM_OPCODE_C_ID_GET_CLASS_VAR_OBJECT: {
1236 744           int32_t class_var_current_basic_type_id = opcode->operand1;
1237 744           int32_t class_var_index = opcode->operand2;
1238            
1239 744           SPVM_RUNTIME_BASIC_TYPE* class_var_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, class_var_current_basic_type_id);
1240 744           SPVM_RUNTIME_CLASS_VAR* class_var = SPVM_API_BASIC_TYPE_get_class_var_by_index(env->runtime, class_var_current_basic_type, class_var_index);
1241            
1242 744           SPVM_IMPLEMENT_GET_CLASS_VAR_OBJECT(env, stack, &object_vars[opcode->operand0], class_var);
1243 744           break;
1244             }
1245             case SPVM_OPCODE_C_ID_SET_CLASS_VAR_BYTE: {
1246 13           int32_t class_var_current_basic_type_id = opcode->operand0;
1247 13           int32_t class_var_index = opcode->operand1;
1248            
1249 13           SPVM_RUNTIME_BASIC_TYPE* class_var_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, class_var_current_basic_type_id);
1250 13           SPVM_RUNTIME_CLASS_VAR* class_var = SPVM_API_BASIC_TYPE_get_class_var_by_index(env->runtime, class_var_current_basic_type, class_var_index);
1251            
1252 13           SPVM_IMPLEMENT_SET_CLASS_VAR_BYTE(env, stack, class_var, byte_vars[opcode->operand2]);
1253 13           break;
1254             }
1255             case SPVM_OPCODE_C_ID_SET_CLASS_VAR_SHORT: {
1256 13           int32_t class_var_current_basic_type_id = opcode->operand0;
1257 13           int32_t class_var_index = opcode->operand1;
1258            
1259 13           SPVM_RUNTIME_BASIC_TYPE* class_var_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, class_var_current_basic_type_id);
1260 13           SPVM_RUNTIME_CLASS_VAR* class_var = SPVM_API_BASIC_TYPE_get_class_var_by_index(env->runtime, class_var_current_basic_type, class_var_index);
1261            
1262 13           SPVM_IMPLEMENT_SET_CLASS_VAR_SHORT(env, stack, class_var, short_vars[opcode->operand2]);
1263 13           break;
1264             }
1265             case SPVM_OPCODE_C_ID_SET_CLASS_VAR_INT: {
1266 50           int32_t class_var_current_basic_type_id = opcode->operand0;
1267 50           int32_t class_var_index = opcode->operand1;
1268            
1269 50           SPVM_RUNTIME_BASIC_TYPE* class_var_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, class_var_current_basic_type_id);
1270 50           SPVM_RUNTIME_CLASS_VAR* class_var = SPVM_API_BASIC_TYPE_get_class_var_by_index(env->runtime, class_var_current_basic_type, class_var_index);
1271            
1272 50           SPVM_IMPLEMENT_SET_CLASS_VAR_INT(env, stack, class_var, int_vars[opcode->operand2]);
1273 50           break;
1274             }
1275             case SPVM_OPCODE_C_ID_SET_CLASS_VAR_LONG: {
1276 16           int32_t class_var_current_basic_type_id = opcode->operand0;
1277 16           int32_t class_var_index = opcode->operand1;
1278            
1279 16           SPVM_RUNTIME_BASIC_TYPE* class_var_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, class_var_current_basic_type_id);
1280 16           SPVM_RUNTIME_CLASS_VAR* class_var = SPVM_API_BASIC_TYPE_get_class_var_by_index(env->runtime, class_var_current_basic_type, class_var_index);
1281            
1282 16           SPVM_IMPLEMENT_SET_CLASS_VAR_LONG(env, stack, class_var, long_vars[opcode->operand2]);
1283 16           break;
1284             }
1285             case SPVM_OPCODE_C_ID_SET_CLASS_VAR_FLOAT: {
1286 13           int32_t class_var_current_basic_type_id = opcode->operand0;
1287 13           int32_t class_var_index = opcode->operand1;
1288            
1289 13           SPVM_RUNTIME_BASIC_TYPE* class_var_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, class_var_current_basic_type_id);
1290 13           SPVM_RUNTIME_CLASS_VAR* class_var = SPVM_API_BASIC_TYPE_get_class_var_by_index(env->runtime, class_var_current_basic_type, class_var_index);
1291            
1292 13           SPVM_IMPLEMENT_SET_CLASS_VAR_FLOAT(env, stack, class_var, float_vars[opcode->operand2]);
1293 13           break;
1294             }
1295             case SPVM_OPCODE_C_ID_SET_CLASS_VAR_DOUBLE: {
1296 13           int32_t class_var_current_basic_type_id = opcode->operand0;
1297 13           int32_t class_var_index = opcode->operand1;
1298            
1299 13           SPVM_RUNTIME_BASIC_TYPE* class_var_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, class_var_current_basic_type_id);
1300 13           SPVM_RUNTIME_CLASS_VAR* class_var = SPVM_API_BASIC_TYPE_get_class_var_by_index(env->runtime, class_var_current_basic_type, class_var_index);
1301            
1302 13           SPVM_IMPLEMENT_SET_CLASS_VAR_DOUBLE(env, stack, class_var, double_vars[opcode->operand2]);
1303 13           break;
1304             }
1305             case SPVM_OPCODE_C_ID_SET_CLASS_VAR_OBJECT: {
1306 666           int32_t class_var_current_basic_type_id = opcode->operand0;
1307 666           int32_t class_var_index = opcode->operand1;
1308            
1309 666           SPVM_RUNTIME_BASIC_TYPE* class_var_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, class_var_current_basic_type_id);
1310 666           SPVM_RUNTIME_CLASS_VAR* class_var = SPVM_API_BASIC_TYPE_get_class_var_by_index(env->runtime, class_var_current_basic_type, class_var_index);
1311            
1312 666           SPVM_IMPLEMENT_SET_CLASS_VAR_OBJECT(env, stack, class_var, object_vars[opcode->operand2]);
1313 666           break;
1314             }
1315             case SPVM_OPCODE_C_ID_SET_CLASS_VAR_UNDEF: {
1316 4           int32_t class_var_current_basic_type_id = opcode->operand0;
1317 4           int32_t class_var_index = opcode->operand1;
1318            
1319 4           SPVM_RUNTIME_BASIC_TYPE* class_var_current_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, class_var_current_basic_type_id);
1320 4           SPVM_RUNTIME_CLASS_VAR* class_var = SPVM_API_BASIC_TYPE_get_class_var_by_index(env->runtime, class_var_current_basic_type, class_var_index);
1321            
1322 4           SPVM_IMPLEMENT_SET_CLASS_VAR_UNDEF(env, stack, class_var);
1323 4           break;
1324             }
1325             case SPVM_OPCODE_C_ID_GET_EXCEPTION_VAR: {
1326 617           SPVM_IMPLEMENT_GET_EXCEPTION_VAR(env, stack, &object_vars[opcode->operand0]);
1327 617           break;
1328             }
1329             case SPVM_OPCODE_C_ID_SET_EXCEPTION_VAR: {
1330 536           SPVM_IMPLEMENT_SET_EXCEPTION_VAR(env, stack, object_vars[opcode->operand0]);
1331 536           break;
1332             }
1333             case SPVM_OPCODE_C_ID_SET_EXCEPTION_VAR_UNDEF: {
1334 837           SPVM_IMPLEMENT_SET_EXCEPTION_VAR_UNDEF(env, stack);
1335 837           break;
1336             }
1337             case SPVM_OPCODE_C_ID_ISA: {
1338 138           void* object = object_vars[opcode->operand1];
1339 138           int32_t basic_type_id = opcode->operand2;
1340 138           int32_t type_dimension = opcode->operand3;
1341            
1342 138           SPVM_RUNTIME_BASIC_TYPE* basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(env->runtime, basic_type_id);
1343            
1344 138           SPVM_IMPLEMENT_ISA(env, stack, &int_vars[0], object, basic_type, type_dimension);
1345 138           break;
1346             }
1347             case SPVM_OPCODE_C_ID_ISA_ERROR: {
1348 7           int32_t src_basic_type_id = int_vars[opcode->operand1];
1349 7           int32_t basic_type_id = opcode->operand2;
1350 7           int32_t type_dimension = opcode->operand3;
1351            
1352 7           void* src_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(env->runtime, src_basic_type_id);
1353            
1354 7           SPVM_RUNTIME_BASIC_TYPE* basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(env->runtime, basic_type_id);
1355            
1356 7           SPVM_IMPLEMENT_ISA_ERROR(env, stack, &int_vars[0], src_basic_type, basic_type, type_dimension);
1357 7           break;
1358             }
1359             case SPVM_OPCODE_C_ID_IS_TYPE: {
1360 91           void* object = object_vars[opcode->operand1];
1361 91           int32_t basic_type_id = opcode->operand2;
1362 91           int32_t type_dimension = opcode->operand3;
1363            
1364 91           SPVM_RUNTIME_BASIC_TYPE* basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(env->runtime, basic_type_id);
1365            
1366 91           SPVM_IMPLEMENT_IS_TYPE(env, stack, &int_vars[0], object, basic_type, type_dimension);
1367 91           break;
1368             }
1369             case SPVM_OPCODE_C_ID_IS_ERROR: {
1370 6           int32_t src_basic_type_id = int_vars[opcode->operand1];
1371 6           int32_t basic_type_id = opcode->operand2;
1372 6           int32_t type_dimension = opcode->operand3;
1373            
1374 6           SPVM_RUNTIME_BASIC_TYPE* basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, basic_type_id);
1375            
1376 6           void* src_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, src_basic_type_id);
1377            
1378 6           SPVM_IMPLEMENT_IS_ERROR(env, stack, &int_vars[0], src_basic_type, basic_type, type_dimension);
1379 6           break;
1380             }
1381             case SPVM_OPCODE_C_ID_CAN: {
1382 5           void* object = object_vars[opcode->operand0];
1383 5           int32_t invocant_decl_basic_type_id = opcode->operand1;
1384 5           int32_t decl_method_index = opcode->operand2;
1385            
1386 5           SPVM_RUNTIME_BASIC_TYPE* invocant_decl_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, invocant_decl_basic_type_id);
1387 5           SPVM_RUNTIME_METHOD* method = SPVM_API_BASIC_TYPE_get_method_by_index(runtime, invocant_decl_basic_type, decl_method_index);
1388 5           const char* method_name = method->name;
1389 5           SPVM_IMPLEMENT_CAN(env, stack, int_vars[0], object, method_name);
1390 5           break;
1391             }
1392             case SPVM_OPCODE_C_ID_PRINT: {
1393 8           void* string = object_vars[opcode->operand0];
1394 8           SPVM_IMPLEMENT_PRINT(env, stack, string);
1395 8           break;
1396             }
1397             case SPVM_OPCODE_C_ID_SAY: {
1398 5           void* string = object_vars[opcode->operand0];
1399 5           SPVM_IMPLEMENT_SAY(env, stack, string);
1400 5           break;
1401             }
1402             case SPVM_OPCODE_C_ID_WARN: {
1403 10           void* string = object_vars[opcode->operand0];
1404 10           int32_t line = opcode->operand1;
1405            
1406 10           const char* class_dir = current_basic_type->class_dir;
1407             const char* class_dir_sep;
1408 10 50         if (class_dir) {
1409 10           class_dir_sep = "/";
1410             }
1411             else {
1412 0           class_dir_sep = "";
1413 0           class_dir = "";
1414             }
1415 10           const char* class_rel_file = current_basic_type->class_rel_file;
1416            
1417 10           SPVM_IMPLEMENT_WARN(env, stack, string, class_dir, class_dir_sep, class_rel_file, line);
1418            
1419 10           break;
1420             }
1421             case SPVM_OPCODE_C_ID_CLEAR_EVAL_ERROR_ID: {
1422 610           SPVM_IMPLEMENT_CLEAR_EVAL_ERROR_ID(eval_error_id);
1423 610           break;
1424             }
1425             case SPVM_OPCODE_C_ID_GET_EVAL_ERROR_ID: {
1426 5           SPVM_IMPLEMENT_GET_EVAL_ERROR_ID(int_vars[opcode->operand0], eval_error_id);
1427 5           break;
1428             }
1429             case SPVM_OPCODE_C_ID_SET_ERROR_ID: {
1430 530           int32_t basic_type_id = opcode->operand0;
1431            
1432 530           SPVM_RUNTIME_BASIC_TYPE* basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(env->runtime, basic_type_id);
1433            
1434 530           SPVM_IMPLEMENT_SET_ERROR_ID(error_id, basic_type);
1435 530           break;
1436             }
1437             case SPVM_OPCODE_C_ID_GET_BASIC_TYPE_ID: {
1438 31           int32_t basic_type_id = opcode->operand1;
1439            
1440 31           SPVM_RUNTIME_BASIC_TYPE* basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(env->runtime, basic_type_id);
1441            
1442 31           SPVM_IMPLEMENT_GET_BASIC_TYPE_ID(env, stack, int_vars[opcode->operand0], basic_type);
1443            
1444 31           break;
1445             }
1446             case SPVM_OPCODE_C_ID_ARGS_WIDTH: {
1447 8           SPVM_IMPLEMENT_ARGS_WIDTH(env, stack, int_vars[opcode->operand0]);
1448 8           break;
1449             }
1450             case SPVM_OPCODE_C_ID_TYPE_NAME: {
1451 5           void* object = object_vars[opcode->operand1];
1452 5           SPVM_IMPLEMENT_TYPE_NAME(env, stack, &object_vars[opcode->operand0], object);
1453 5           break;
1454             }
1455             case SPVM_OPCODE_C_ID_DUMP: {
1456 31           void* object = object_vars[opcode->operand1];
1457 31           SPVM_IMPLEMENT_DUMP(env, stack, &object_vars[opcode->operand0], object);
1458 31           break;
1459             }
1460             case SPVM_OPCODE_C_ID_COPY: {
1461 146           void* object = object_vars[opcode->operand1];
1462 146           SPVM_IMPLEMENT_COPY(env, stack, &object_vars[opcode->operand0], object, &error_id);
1463 146           break;
1464             }
1465             case SPVM_OPCODE_C_ID_REF_BYTE: {
1466 13           SPVM_IMPLEMENT_REF_BYTE(ref_vars[opcode->operand0], &byte_vars[opcode->operand1]);
1467 13           break;
1468             }
1469             case SPVM_OPCODE_C_ID_REF_SHORT: {
1470 11           SPVM_IMPLEMENT_REF_SHORT(ref_vars[opcode->operand0], &short_vars[opcode->operand1]);
1471 11           break;
1472             }
1473             case SPVM_OPCODE_C_ID_REF_INT: {
1474 400253           SPVM_IMPLEMENT_REF_INT(ref_vars[opcode->operand0], &int_vars[opcode->operand1]);
1475 400253           break;
1476             }
1477             case SPVM_OPCODE_C_ID_REF_LONG: {
1478 11           SPVM_IMPLEMENT_REF_LONG(ref_vars[opcode->operand0], &long_vars[opcode->operand1]);
1479 11           break;
1480             }
1481             case SPVM_OPCODE_C_ID_REF_FLOAT: {
1482 11           SPVM_IMPLEMENT_REF_FLOAT(ref_vars[opcode->operand0], &float_vars[opcode->operand1]);
1483 11           break;
1484             }
1485             case SPVM_OPCODE_C_ID_REF_DOUBLE: {
1486 12           SPVM_IMPLEMENT_REF_DOUBLE(ref_vars[opcode->operand0], &double_vars[opcode->operand1]);
1487 12           break;
1488             }
1489             case SPVM_OPCODE_C_ID_GET_DEREF_BYTE: {
1490 16           SPVM_IMPLEMENT_GET_DEREF_BYTE(byte_vars[opcode->operand0], &ref_vars[opcode->operand1]);
1491 16           break;
1492             }
1493             case SPVM_OPCODE_C_ID_GET_DEREF_SHORT: {
1494 14           SPVM_IMPLEMENT_GET_DEREF_SHORT(short_vars[opcode->operand0], &ref_vars[opcode->operand1]);
1495 14           break;
1496             }
1497             case SPVM_OPCODE_C_ID_GET_DEREF_INT: {
1498 26           SPVM_IMPLEMENT_GET_DEREF_INT(int_vars[opcode->operand0], &ref_vars[opcode->operand1]);
1499 26           break;
1500             }
1501             case SPVM_OPCODE_C_ID_GET_DEREF_LONG: {
1502 14           SPVM_IMPLEMENT_GET_DEREF_LONG(long_vars[opcode->operand0], &ref_vars[opcode->operand1]);
1503 14           break;
1504             }
1505             case SPVM_OPCODE_C_ID_GET_DEREF_FLOAT: {
1506 14           SPVM_IMPLEMENT_GET_DEREF_FLOAT(float_vars[opcode->operand0], &ref_vars[opcode->operand1]);
1507 14           break;
1508             }
1509             case SPVM_OPCODE_C_ID_GET_DEREF_DOUBLE: {
1510 15           SPVM_IMPLEMENT_GET_DEREF_DOUBLE(double_vars[opcode->operand0], &ref_vars[opcode->operand1]);
1511 15           break;
1512             }
1513             case SPVM_OPCODE_C_ID_SET_DEREF_BYTE: {
1514 10           SPVM_IMPLEMENT_SET_DEREF_BYTE(&ref_vars[opcode->operand0], byte_vars[opcode->operand1]);
1515 10           break;
1516             }
1517             case SPVM_OPCODE_C_ID_SET_DEREF_SHORT: {
1518 9           SPVM_IMPLEMENT_SET_DEREF_SHORT(&ref_vars[opcode->operand0], short_vars[opcode->operand1]);
1519 9           break;
1520             }
1521             case SPVM_OPCODE_C_ID_SET_DEREF_INT: {
1522 13           SPVM_IMPLEMENT_SET_DEREF_INT(&ref_vars[opcode->operand0], int_vars[opcode->operand1]);
1523 13           break;
1524             }
1525             case SPVM_OPCODE_C_ID_SET_DEREF_LONG: {
1526 9           SPVM_IMPLEMENT_SET_DEREF_LONG(&ref_vars[opcode->operand0], long_vars[opcode->operand1]);
1527 9           break;
1528             }
1529             case SPVM_OPCODE_C_ID_SET_DEREF_FLOAT: {
1530 9           SPVM_IMPLEMENT_SET_DEREF_FLOAT(&ref_vars[opcode->operand0], float_vars[opcode->operand1]);
1531 9           break;
1532             }
1533             case SPVM_OPCODE_C_ID_SET_DEREF_DOUBLE: {
1534 9           SPVM_IMPLEMENT_SET_DEREF_DOUBLE(&ref_vars[opcode->operand0], double_vars[opcode->operand1]);
1535 9           break;
1536             }
1537             case SPVM_OPCODE_C_ID_GET_MULNUM_FIELD_BYTE: {
1538 89           int32_t field_index = opcode->operand2;
1539 89           SPVM_IMPLEMENT_GET_MULNUM_FIELD_BYTE(byte_vars[opcode->operand0], &byte_vars[opcode->operand1], field_index);
1540 89           break;
1541             }
1542             case SPVM_OPCODE_C_ID_GET_MULNUM_FIELD_SHORT: {
1543 85           int32_t field_index = opcode->operand2;
1544 85           SPVM_IMPLEMENT_GET_MULNUM_FIELD_SHORT(short_vars[opcode->operand0], &short_vars[opcode->operand1], field_index);
1545 85           break;
1546             }
1547             case SPVM_OPCODE_C_ID_GET_MULNUM_FIELD_INT: {
1548 85           int32_t field_index = opcode->operand2;
1549 85           SPVM_IMPLEMENT_GET_MULNUM_FIELD_INT(int_vars[opcode->operand0], &int_vars[opcode->operand1], field_index);
1550 85           break;
1551             }
1552             case SPVM_OPCODE_C_ID_GET_MULNUM_FIELD_LONG: {
1553 85           int32_t field_index = opcode->operand2;
1554 85           SPVM_IMPLEMENT_GET_MULNUM_FIELD_LONG(long_vars[opcode->operand0], &long_vars[opcode->operand1], field_index);
1555 85           break;
1556             }
1557             case SPVM_OPCODE_C_ID_GET_MULNUM_FIELD_FLOAT: {
1558 85           int32_t field_index = opcode->operand2;
1559 85           SPVM_IMPLEMENT_GET_MULNUM_FIELD_FLOAT(float_vars[opcode->operand0], &float_vars[opcode->operand1], field_index);
1560 85           break;
1561             }
1562             case SPVM_OPCODE_C_ID_GET_MULNUM_FIELD_DOUBLE: {
1563 92           int32_t field_index = opcode->operand2;
1564 92           SPVM_IMPLEMENT_GET_MULNUM_FIELD_DOUBLE(double_vars[opcode->operand0], &double_vars[opcode->operand1], field_index);
1565 92           break;
1566             }
1567             case SPVM_OPCODE_C_ID_SET_MULNUM_FIELD_BYTE: {
1568 76           int32_t field_index = opcode->operand2;
1569 76           SPVM_IMPLEMENT_SET_MULNUM_FIELD_BYTE(&byte_vars[opcode->operand0], field_index, byte_vars[opcode->operand1]);
1570 76           break;
1571             }
1572             case SPVM_OPCODE_C_ID_SET_MULNUM_FIELD_SHORT: {
1573 74           int32_t field_index = opcode->operand2;
1574 74           SPVM_IMPLEMENT_SET_MULNUM_FIELD_SHORT(&short_vars[opcode->operand0], field_index, short_vars[opcode->operand1]);
1575 74           break;
1576             }
1577             case SPVM_OPCODE_C_ID_SET_MULNUM_FIELD_INT: {
1578 74           int32_t field_index = opcode->operand2;
1579 74           SPVM_IMPLEMENT_SET_MULNUM_FIELD_INT(&int_vars[opcode->operand0], field_index, int_vars[opcode->operand1]);
1580 74           break;
1581             }
1582             case SPVM_OPCODE_C_ID_SET_MULNUM_FIELD_LONG: {
1583 74           int32_t field_index = opcode->operand2;
1584 74           SPVM_IMPLEMENT_SET_MULNUM_FIELD_LONG(&long_vars[opcode->operand0], field_index, long_vars[opcode->operand1]);
1585 74           break;
1586             }
1587             case SPVM_OPCODE_C_ID_SET_MULNUM_FIELD_FLOAT: {
1588 71           int32_t field_index = opcode->operand2;
1589 71           SPVM_IMPLEMENT_SET_MULNUM_FIELD_FLOAT(&float_vars[opcode->operand0], field_index, float_vars[opcode->operand1]);
1590 71           break;
1591             }
1592             case SPVM_OPCODE_C_ID_SET_MULNUM_FIELD_DOUBLE: {
1593 76           int32_t field_index = opcode->operand2;
1594 76           SPVM_IMPLEMENT_SET_MULNUM_FIELD_DOUBLE(&double_vars[opcode->operand0], field_index, double_vars[opcode->operand1]);
1595 76           break;
1596             }
1597             case SPVM_OPCODE_C_ID_MOVE_MULNUM_BYTE: {
1598 0           int32_t fields_length = opcode->operand2;
1599 0           SPVM_IMPLEMENT_MOVE_MULNUM_BYTE(env, stack, &byte_vars[opcode->operand0], &byte_vars[opcode->operand1], fields_length);
1600 0           break;
1601             }
1602             case SPVM_OPCODE_C_ID_MOVE_MULNUM_SHORT: {
1603 0           int32_t fields_length = opcode->operand2;
1604 0           SPVM_IMPLEMENT_MOVE_MULNUM_SHORT(env, stack, &short_vars[opcode->operand0], &short_vars[opcode->operand1], fields_length);
1605 0           break;
1606             }
1607             case SPVM_OPCODE_C_ID_MOVE_MULNUM_INT: {
1608 0           int32_t fields_length = opcode->operand2;
1609 0           SPVM_IMPLEMENT_MOVE_MULNUM_INT(env, stack, &int_vars[opcode->operand0], &int_vars[opcode->operand1], fields_length);
1610 0           break;
1611             }
1612             case SPVM_OPCODE_C_ID_MOVE_MULNUM_LONG: {
1613 0           int32_t fields_length = opcode->operand2;
1614 0           SPVM_IMPLEMENT_MOVE_MULNUM_LONG(env, stack, &long_vars[opcode->operand0], &long_vars[opcode->operand1], fields_length);
1615 0           break;
1616             }
1617             case SPVM_OPCODE_C_ID_MOVE_MULNUM_FLOAT: {
1618 0           int32_t fields_length = opcode->operand2;
1619 0           SPVM_IMPLEMENT_MOVE_MULNUM_FLOAT(env, stack, &float_vars[opcode->operand0], &float_vars[opcode->operand1], fields_length);
1620 0           break;
1621             }
1622             case SPVM_OPCODE_C_ID_MOVE_MULNUM_DOUBLE: {
1623 3           int32_t fields_length = opcode->operand2;
1624 3           SPVM_IMPLEMENT_MOVE_MULNUM_DOUBLE(env, stack, &double_vars[opcode->operand0], &double_vars[opcode->operand1], fields_length);
1625 3           break;
1626             }
1627             case SPVM_OPCODE_C_ID_GET_MULNUM_ARRAY_BYTE: {
1628 1           void* array = object_vars[opcode->operand1];
1629 1           int32_t index = int_vars[opcode->operand2];
1630 1           int32_t fields_length = opcode->operand3;
1631 1           SPVM_IMPLEMENT_GET_MULNUM_ARRAY_BYTE(env, stack, &byte_vars[opcode->operand0], array, index, fields_length, &error_id, object_data_offset, object_length_offset);
1632 1           break;
1633             }
1634             case SPVM_OPCODE_C_ID_GET_MULNUM_ARRAY_SHORT: {
1635 1           void* array = object_vars[opcode->operand1];
1636 1           int32_t index = int_vars[opcode->operand2];
1637 1           int32_t fields_length = opcode->operand3;
1638 1           SPVM_IMPLEMENT_GET_MULNUM_ARRAY_SHORT(env, stack, &short_vars[opcode->operand0], array, index, fields_length, &error_id, object_data_offset, object_length_offset);
1639 1           break;
1640             }
1641             case SPVM_OPCODE_C_ID_GET_MULNUM_ARRAY_INT: {
1642 1           void* array = object_vars[opcode->operand1];
1643 1           int32_t index = int_vars[opcode->operand2];
1644 1           int32_t fields_length = opcode->operand3;
1645 1           SPVM_IMPLEMENT_GET_MULNUM_ARRAY_INT(env, stack, &int_vars[opcode->operand0], array, index, fields_length, &error_id, object_data_offset, object_length_offset);
1646 1           break;
1647             }
1648             case SPVM_OPCODE_C_ID_GET_MULNUM_ARRAY_LONG: {
1649 1           void* array = object_vars[opcode->operand1];
1650 1           int32_t index = int_vars[opcode->operand2];
1651 1           int32_t fields_length = opcode->operand3;
1652 1           SPVM_IMPLEMENT_GET_MULNUM_ARRAY_LONG(env, stack, &long_vars[opcode->operand0], array, index, fields_length, &error_id, object_data_offset, object_length_offset);
1653 1           break;
1654             }
1655             case SPVM_OPCODE_C_ID_GET_MULNUM_ARRAY_FLOAT: {
1656 1           void* array = object_vars[opcode->operand1];
1657 1           int32_t index = int_vars[opcode->operand2];
1658 1           int32_t fields_length = opcode->operand3;
1659 1           SPVM_IMPLEMENT_GET_MULNUM_ARRAY_FLOAT(env, stack, &float_vars[opcode->operand0], array, index, fields_length, &error_id, object_data_offset, object_length_offset);
1660 1           break;
1661             }
1662             case SPVM_OPCODE_C_ID_GET_MULNUM_ARRAY_DOUBLE: {
1663 1           void* array = object_vars[opcode->operand1];
1664 1           int32_t index = int_vars[opcode->operand2];
1665 1           int32_t fields_length = opcode->operand3;
1666 1           SPVM_IMPLEMENT_GET_MULNUM_ARRAY_DOUBLE(env, stack, &double_vars[opcode->operand0], array, index, fields_length, &error_id, object_data_offset, object_length_offset);
1667 1           break;
1668             }
1669             case SPVM_OPCODE_C_ID_SET_MULNUM_ARRAY_BYTE: {
1670 1           void* array = object_vars[opcode->operand0];
1671 1           int32_t index = int_vars[opcode->operand1];
1672 1           int32_t fields_length = opcode->operand3;
1673 1           SPVM_IMPLEMENT_SET_MULNUM_ARRAY_BYTE(env, stack, array, index, fields_length, &byte_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
1674 1           break;
1675             }
1676             case SPVM_OPCODE_C_ID_SET_MULNUM_ARRAY_SHORT: {
1677 1           void* array = object_vars[opcode->operand0];
1678 1           int32_t index = int_vars[opcode->operand1];
1679 1           int32_t fields_length = opcode->operand3;
1680 1           SPVM_IMPLEMENT_SET_MULNUM_ARRAY_SHORT(env, stack, array, index, fields_length, &short_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
1681 1           break;
1682             }
1683             case SPVM_OPCODE_C_ID_SET_MULNUM_ARRAY_INT: {
1684 1           void* array = object_vars[opcode->operand0];
1685 1           int32_t index = int_vars[opcode->operand1];
1686 1           int32_t fields_length = opcode->operand3;
1687 1           SPVM_IMPLEMENT_SET_MULNUM_ARRAY_INT(env, stack, array, index, fields_length, &int_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
1688 1           break;
1689             }
1690             case SPVM_OPCODE_C_ID_SET_MULNUM_ARRAY_LONG: {
1691 1           void* array = object_vars[opcode->operand0];
1692 1           int32_t index = int_vars[opcode->operand1];
1693 1           int32_t fields_length = opcode->operand3;
1694 1           SPVM_IMPLEMENT_SET_MULNUM_ARRAY_LONG(env, stack, array, index, fields_length, &long_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
1695 1           break;
1696             }
1697             case SPVM_OPCODE_C_ID_SET_MULNUM_ARRAY_FLOAT: {
1698 1           void* array = object_vars[opcode->operand0];
1699 1           int32_t index = int_vars[opcode->operand1];
1700 1           int32_t fields_length = opcode->operand3;
1701 1           SPVM_IMPLEMENT_SET_MULNUM_ARRAY_FLOAT(env, stack, array, index, fields_length, &float_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
1702 1           break;
1703             }
1704             case SPVM_OPCODE_C_ID_SET_MULNUM_ARRAY_DOUBLE: {
1705 1           void* array = object_vars[opcode->operand0];
1706 1           int32_t index = int_vars[opcode->operand1];
1707 1           int32_t fields_length = opcode->operand3;
1708 1           SPVM_IMPLEMENT_SET_MULNUM_ARRAY_DOUBLE(env, stack, array, index, fields_length, &double_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
1709 1           break;
1710             }
1711             case SPVM_OPCODE_C_ID_GET_MULNUM_ARRAY_FIELD_BYTE: {
1712 94           void* array = object_vars[opcode->operand1];
1713 94           int32_t index = int_vars[opcode->operand2];
1714 94           int32_t fields_length = (opcode->operand3 & 0xFF) + 1;
1715 94           int32_t field_index = opcode->operand3 >> 8;
1716 94           SPVM_IMPLEMENT_GET_MULNUM_ARRAY_FIELD_BYTE(env, stack, &byte_vars[opcode->operand0], array, index, field_index, fields_length, &error_id, object_data_offset, object_length_offset);
1717 94           break;
1718             }
1719             case SPVM_OPCODE_C_ID_GET_MULNUM_ARRAY_FIELD_SHORT: {
1720 94           void* array = object_vars[opcode->operand1];
1721 94           int32_t index = int_vars[opcode->operand2];
1722 94           int32_t fields_length = (opcode->operand3 & 0xFF) + 1;
1723 94           int32_t field_index = opcode->operand3 >> 8;
1724 94           SPVM_IMPLEMENT_GET_MULNUM_ARRAY_FIELD_SHORT(env, stack, &short_vars[opcode->operand0], array, index, field_index, fields_length, &error_id, object_data_offset, object_length_offset);
1725 94           break;
1726             }
1727             case SPVM_OPCODE_C_ID_GET_MULNUM_ARRAY_FIELD_INT: {
1728 104           void* array = object_vars[opcode->operand1];
1729 104           int32_t index = int_vars[opcode->operand2];
1730 104           int32_t fields_length = (opcode->operand3 & 0xFF) + 1;
1731 104           int32_t field_index = opcode->operand3 >> 8;
1732 104           SPVM_IMPLEMENT_GET_MULNUM_ARRAY_FIELD_INT(env, stack, &int_vars[opcode->operand0], array, index, field_index, fields_length, &error_id, object_data_offset, object_length_offset);
1733 104           break;
1734             }
1735             case SPVM_OPCODE_C_ID_GET_MULNUM_ARRAY_FIELD_LONG: {
1736 94           void* array = object_vars[opcode->operand1];
1737 94           int32_t index = int_vars[opcode->operand2];
1738 94           int32_t fields_length = (opcode->operand3 & 0xFF) + 1;
1739 94           int32_t field_index = opcode->operand3 >> 8;
1740 94           SPVM_IMPLEMENT_GET_MULNUM_ARRAY_FIELD_LONG(env, stack, &long_vars[opcode->operand0], array, index, field_index, fields_length, &error_id, object_data_offset, object_length_offset);
1741 94           break;
1742             }
1743             case SPVM_OPCODE_C_ID_GET_MULNUM_ARRAY_FIELD_FLOAT: {
1744 94           void* array = object_vars[opcode->operand1];
1745 94           int32_t index = int_vars[opcode->operand2];
1746 94           int32_t fields_length = (opcode->operand3 & 0xFF) + 1;
1747 94           int32_t field_index = opcode->operand3 >> 8;
1748 94           SPVM_IMPLEMENT_GET_MULNUM_ARRAY_FIELD_FLOAT(env, stack, &float_vars[opcode->operand0], array, index, field_index, fields_length, &error_id, object_data_offset, object_length_offset);
1749 94           break;
1750             }
1751             case SPVM_OPCODE_C_ID_GET_MULNUM_ARRAY_FIELD_DOUBLE: {
1752 111           void* array = object_vars[opcode->operand1];
1753 111           int32_t index = int_vars[opcode->operand2];
1754 111           int32_t fields_length = (opcode->operand3 & 0xFF) + 1;
1755 111           int32_t field_index = opcode->operand3 >> 8;
1756 111           SPVM_IMPLEMENT_GET_MULNUM_ARRAY_FIELD_DOUBLE(env, stack, &double_vars[opcode->operand0], array, index, field_index, fields_length, &error_id, object_data_offset, object_length_offset);
1757 111           break;
1758             }
1759             case SPVM_OPCODE_C_ID_SET_MULNUM_ARRAY_FIELD_BYTE: {
1760 79           void* array = object_vars[opcode->operand0];
1761 79           int32_t index = int_vars[opcode->operand1];
1762 79           int32_t fields_length = (opcode->operand3 & 0xFF) + 1;
1763 79           int32_t field_index = opcode->operand3 >> 8;
1764 79           SPVM_IMPLEMENT_SET_MULNUM_ARRAY_FIELD_BYTE(env, stack, array, index, field_index, fields_length, byte_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
1765 79           break;
1766             }
1767             case SPVM_OPCODE_C_ID_SET_MULNUM_ARRAY_FIELD_SHORT: {
1768 79           void* array = object_vars[opcode->operand0];
1769 79           int32_t index = int_vars[opcode->operand1];
1770 79           int32_t fields_length = (opcode->operand3 & 0xFF) + 1;
1771 79           int32_t field_index = opcode->operand3 >> 8;
1772 79           SPVM_IMPLEMENT_SET_MULNUM_ARRAY_FIELD_SHORT(env, stack, array, index, field_index, fields_length, short_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
1773 79           break;
1774             }
1775             case SPVM_OPCODE_C_ID_SET_MULNUM_ARRAY_FIELD_INT: {
1776 86           void* array = object_vars[opcode->operand0];
1777 86           int32_t index = int_vars[opcode->operand1];
1778 86           int32_t fields_length = (opcode->operand3 & 0xFF) + 1;
1779 86           int32_t field_index = opcode->operand3 >> 8;
1780 86           SPVM_IMPLEMENT_SET_MULNUM_ARRAY_FIELD_INT(env, stack, array, index, field_index, fields_length, int_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
1781 86           break;
1782             }
1783             case SPVM_OPCODE_C_ID_SET_MULNUM_ARRAY_FIELD_LONG: {
1784 79           void* array = object_vars[opcode->operand0];
1785 79           int32_t index = int_vars[opcode->operand1];
1786 79           int32_t fields_length = (opcode->operand3 & 0xFF) + 1;
1787 79           int32_t field_index = opcode->operand3 >> 8;
1788 79           SPVM_IMPLEMENT_SET_MULNUM_ARRAY_FIELD_LONG(env, stack, array, index, field_index, fields_length, long_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
1789 79           break;
1790             }
1791             case SPVM_OPCODE_C_ID_SET_MULNUM_ARRAY_FIELD_FLOAT: {
1792 67           void* array = object_vars[opcode->operand0];
1793 67           int32_t index = int_vars[opcode->operand1];
1794 67           int32_t fields_length = (opcode->operand3 & 0xFF) + 1;
1795 67           int32_t field_index = opcode->operand3 >> 8;
1796 67           SPVM_IMPLEMENT_SET_MULNUM_ARRAY_FIELD_FLOAT(env, stack, array, index, field_index, fields_length, float_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
1797 67           break;
1798             }
1799             case SPVM_OPCODE_C_ID_SET_MULNUM_ARRAY_FIELD_DOUBLE: {
1800 79           void* array = object_vars[opcode->operand0];
1801 79           int32_t index = int_vars[opcode->operand1];
1802 79           int32_t fields_length = (opcode->operand3 & 0xFF) + 1;
1803 79           int32_t field_index = opcode->operand3 >> 8;
1804 79           SPVM_IMPLEMENT_SET_MULNUM_ARRAY_FIELD_DOUBLE(env, stack, array, index, field_index, fields_length, double_vars[opcode->operand2], &error_id, object_data_offset, object_length_offset);
1805 79           break;
1806             }
1807             case SPVM_OPCODE_C_ID_DEREF_MULNUM_BYTE: {
1808 2           int32_t fields_length = opcode->operand3;
1809 2           SPVM_IMPLEMENT_DEREF_MULNUM_BYTE(env, stack, &byte_vars[opcode->operand0], ref_vars[opcode->operand1], fields_length);
1810 2           break;
1811             }
1812             case SPVM_OPCODE_C_ID_DEREF_MULNUM_SHORT: {
1813 1           int32_t fields_length = opcode->operand3;
1814 1           SPVM_IMPLEMENT_DEREF_MULNUM_SHORT(env, stack, &short_vars[opcode->operand0], ref_vars[opcode->operand1], fields_length);
1815 1           break;
1816             }
1817             case SPVM_OPCODE_C_ID_DEREF_MULNUM_INT: {
1818 1           int32_t fields_length = opcode->operand3;
1819 1           SPVM_IMPLEMENT_DEREF_MULNUM_INT(env, stack, &int_vars[opcode->operand0], ref_vars[opcode->operand1], fields_length);
1820 1           break;
1821             }
1822             case SPVM_OPCODE_C_ID_DEREF_MULNUM_LONG: {
1823 1           int32_t fields_length = opcode->operand3;
1824 1           SPVM_IMPLEMENT_DEREF_MULNUM_LONG(env, stack, &long_vars[opcode->operand0], ref_vars[opcode->operand1], fields_length);
1825 1           break;
1826             }
1827             case SPVM_OPCODE_C_ID_DEREF_MULNUM_FLOAT: {
1828 1           int32_t fields_length = opcode->operand3;
1829 1           SPVM_IMPLEMENT_DEREF_MULNUM_FLOAT(env, stack, &float_vars[opcode->operand0], ref_vars[opcode->operand1], fields_length);
1830 1           break;
1831             }
1832             case SPVM_OPCODE_C_ID_DEREF_MULNUM_DOUBLE: {
1833 1           int32_t fields_length = opcode->operand3;
1834 1           SPVM_IMPLEMENT_DEREF_MULNUM_DOUBLE(env, stack, &double_vars[opcode->operand0], ref_vars[opcode->operand1], fields_length);
1835 1           break;
1836             }
1837             case SPVM_OPCODE_C_ID_GET_MULNUM_FIELD_DEREF_BYTE: {
1838 6           int32_t field_index = opcode->operand2;
1839 6           SPVM_IMPLEMENT_GET_MULNUM_FIELD_DEREF_BYTE(byte_vars[opcode->operand0], ref_vars[opcode->operand1], field_index);
1840 6           break;
1841             }
1842             case SPVM_OPCODE_C_ID_GET_MULNUM_FIELD_DEREF_SHORT: {
1843 6           int32_t field_index = opcode->operand2;
1844 6           SPVM_IMPLEMENT_GET_MULNUM_FIELD_DEREF_SHORT(short_vars[opcode->operand0], ref_vars[opcode->operand1], field_index);
1845 6           break;
1846             }
1847             case SPVM_OPCODE_C_ID_GET_MULNUM_FIELD_DEREF_INT: {
1848 12           int32_t field_index = opcode->operand2;
1849 12           SPVM_IMPLEMENT_GET_MULNUM_FIELD_DEREF_INT(int_vars[opcode->operand0], ref_vars[opcode->operand1], field_index);
1850 12           break;
1851             }
1852             case SPVM_OPCODE_C_ID_GET_MULNUM_FIELD_DEREF_LONG: {
1853 6           int32_t field_index = opcode->operand2;
1854 6           SPVM_IMPLEMENT_GET_MULNUM_FIELD_DEREF_LONG(long_vars[opcode->operand0], ref_vars[opcode->operand1], field_index);
1855 6           break;
1856             }
1857             case SPVM_OPCODE_C_ID_GET_MULNUM_FIELD_DEREF_FLOAT: {
1858 6           int32_t field_index = opcode->operand2;
1859 6           SPVM_IMPLEMENT_GET_MULNUM_FIELD_DEREF_FLOAT(float_vars[opcode->operand0], ref_vars[opcode->operand1], field_index);
1860 6           break;
1861             }
1862             case SPVM_OPCODE_C_ID_GET_MULNUM_FIELD_DEREF_DOUBLE: {
1863 6           int32_t field_index = opcode->operand2;
1864 6           SPVM_IMPLEMENT_GET_MULNUM_FIELD_DEREF_DOUBLE(double_vars[opcode->operand0], ref_vars[opcode->operand1], field_index);
1865 6           break;
1866             }
1867             case SPVM_OPCODE_C_ID_SET_MULNUM_FIELD_DEREF_BYTE: {
1868 9           int32_t field_index = opcode->operand2;
1869 9           SPVM_IMPLEMENT_SET_MULNUM_FIELD_DEREF_BYTE(ref_vars[opcode->operand0], field_index, byte_vars[opcode->operand1]);
1870 9           break;
1871             }
1872             case SPVM_OPCODE_C_ID_SET_MULNUM_FIELD_DEREF_SHORT: {
1873 9           int32_t field_index = opcode->operand2;
1874 9           SPVM_IMPLEMENT_SET_MULNUM_FIELD_DEREF_SHORT(ref_vars[opcode->operand0], field_index, short_vars[opcode->operand1]);
1875 9           break;
1876             }
1877             case SPVM_OPCODE_C_ID_SET_MULNUM_FIELD_DEREF_INT: {
1878 15           int32_t field_index = opcode->operand2;
1879 15           SPVM_IMPLEMENT_SET_MULNUM_FIELD_DEREF_INT(ref_vars[opcode->operand0], field_index, int_vars[opcode->operand1]);
1880 15           break;
1881             }
1882             case SPVM_OPCODE_C_ID_SET_MULNUM_FIELD_DEREF_LONG: {
1883 9           int32_t field_index = opcode->operand2;
1884 9           SPVM_IMPLEMENT_SET_MULNUM_FIELD_DEREF_LONG(ref_vars[opcode->operand0], field_index, long_vars[opcode->operand1]);
1885 9           break;
1886             }
1887             case SPVM_OPCODE_C_ID_SET_MULNUM_FIELD_DEREF_FLOAT: {
1888 12           int32_t field_index = opcode->operand2;
1889 12           SPVM_IMPLEMENT_SET_MULNUM_FIELD_DEREF_FLOAT(ref_vars[opcode->operand0], field_index, float_vars[opcode->operand1]);
1890 12           break;
1891             }
1892             case SPVM_OPCODE_C_ID_SET_MULNUM_FIELD_DEREF_DOUBLE: {
1893 12           int32_t field_index = opcode->operand2;
1894 12           SPVM_IMPLEMENT_SET_MULNUM_FIELD_DEREF_DOUBLE(ref_vars[opcode->operand0], field_index, double_vars[opcode->operand1]);
1895 12           break;
1896             }
1897             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_BYTE_TO_SHORT: {
1898 5           SPVM_IMPLEMENT_TYPE_CONVERSION_BYTE_TO_SHORT(short_vars[opcode->operand0], byte_vars[opcode->operand1]);
1899 5           break;
1900             }
1901             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_BYTE_TO_INT: {
1902 18151           SPVM_IMPLEMENT_TYPE_CONVERSION_BYTE_TO_INT(int_vars[opcode->operand0], byte_vars[opcode->operand1]);
1903 18151           break;
1904             }
1905             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_BYTE_TO_LONG: {
1906 5           SPVM_IMPLEMENT_TYPE_CONVERSION_BYTE_TO_LONG(long_vars[opcode->operand0], byte_vars[opcode->operand1]);
1907 5           break;
1908             }
1909             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_BYTE_TO_FLOAT: {
1910 8           SPVM_IMPLEMENT_TYPE_CONVERSION_BYTE_TO_FLOAT(float_vars[opcode->operand0], byte_vars[opcode->operand1]);
1911 8           break;
1912             }
1913             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_BYTE_TO_DOUBLE: {
1914 8           SPVM_IMPLEMENT_TYPE_CONVERSION_BYTE_TO_DOUBLE(double_vars[opcode->operand0], byte_vars[opcode->operand1]);
1915 8           break;
1916             }
1917             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_SHORT_TO_BYTE: {
1918 2           SPVM_IMPLEMENT_TYPE_CONVERSION_SHORT_TO_BYTE(byte_vars[opcode->operand0], short_vars[opcode->operand1]);
1919 2           break;
1920             }
1921             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_SHORT_TO_INT: {
1922 1105           SPVM_IMPLEMENT_TYPE_CONVERSION_SHORT_TO_INT(int_vars[opcode->operand0], short_vars[opcode->operand1]);
1923 1105           break;
1924             }
1925             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_SHORT_TO_LONG: {
1926 3           SPVM_IMPLEMENT_TYPE_CONVERSION_SHORT_TO_LONG(long_vars[opcode->operand0], short_vars[opcode->operand1]);
1927 3           break;
1928             }
1929             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_SHORT_TO_FLOAT: {
1930 6           SPVM_IMPLEMENT_TYPE_CONVERSION_SHORT_TO_FLOAT(float_vars[opcode->operand0], short_vars[opcode->operand1]);
1931 6           break;
1932             }
1933             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_SHORT_TO_DOUBLE: {
1934 6           SPVM_IMPLEMENT_TYPE_CONVERSION_SHORT_TO_DOUBLE(double_vars[opcode->operand0], short_vars[opcode->operand1]);
1935 6           break;
1936             }
1937             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_INT_TO_BYTE: {
1938 5172           SPVM_IMPLEMENT_TYPE_CONVERSION_INT_TO_BYTE(byte_vars[opcode->operand0], int_vars[opcode->operand1]);
1939 5172           break;
1940             }
1941             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_INT_TO_SHORT: {
1942 1569           SPVM_IMPLEMENT_TYPE_CONVERSION_INT_TO_SHORT(short_vars[opcode->operand0], int_vars[opcode->operand1]);
1943 1569           break;
1944             }
1945             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_INT_TO_LONG: {
1946 2062           SPVM_IMPLEMENT_TYPE_CONVERSION_INT_TO_LONG(long_vars[opcode->operand0], int_vars[opcode->operand1]);
1947 2062           break;
1948             }
1949             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_INT_TO_FLOAT: {
1950 1342           SPVM_IMPLEMENT_TYPE_CONVERSION_INT_TO_FLOAT(float_vars[opcode->operand0], int_vars[opcode->operand1]);
1951 1342           break;
1952             }
1953             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_INT_TO_DOUBLE: {
1954 2701785           SPVM_IMPLEMENT_TYPE_CONVERSION_INT_TO_DOUBLE(double_vars[opcode->operand0], int_vars[opcode->operand1]);
1955 2701785           break;
1956             }
1957             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_LONG_TO_BYTE: {
1958 2           SPVM_IMPLEMENT_TYPE_CONVERSION_LONG_TO_BYTE(byte_vars[opcode->operand0], long_vars[opcode->operand1]);
1959 2           break;
1960             }
1961             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_LONG_TO_SHORT: {
1962 2           SPVM_IMPLEMENT_TYPE_CONVERSION_LONG_TO_SHORT(short_vars[opcode->operand0], long_vars[opcode->operand1]);
1963 2           break;
1964             }
1965             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_LONG_TO_INT: {
1966 602           SPVM_IMPLEMENT_TYPE_CONVERSION_LONG_TO_INT(int_vars[opcode->operand0], long_vars[opcode->operand1]);
1967 602           break;
1968             }
1969             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_LONG_TO_FLOAT: {
1970 4           SPVM_IMPLEMENT_TYPE_CONVERSION_LONG_TO_FLOAT(float_vars[opcode->operand0], long_vars[opcode->operand1]);
1971 4           break;
1972             }
1973             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_LONG_TO_DOUBLE: {
1974 2           SPVM_IMPLEMENT_TYPE_CONVERSION_LONG_TO_DOUBLE(double_vars[opcode->operand0], long_vars[opcode->operand1]);
1975 2           break;
1976             }
1977             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_FLOAT_TO_BYTE: {
1978 2           SPVM_IMPLEMENT_TYPE_CONVERSION_FLOAT_TO_BYTE(byte_vars[opcode->operand0], float_vars[opcode->operand1]);
1979 2           break;
1980             }
1981             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_FLOAT_TO_SHORT: {
1982 2           SPVM_IMPLEMENT_TYPE_CONVERSION_FLOAT_TO_SHORT(short_vars[opcode->operand0], float_vars[opcode->operand1]);
1983 2           break;
1984             }
1985             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_FLOAT_TO_INT: {
1986 2           SPVM_IMPLEMENT_TYPE_CONVERSION_FLOAT_TO_INT(int_vars[opcode->operand0], float_vars[opcode->operand1]);
1987 2           break;
1988             }
1989             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_FLOAT_TO_LONG: {
1990 2           SPVM_IMPLEMENT_TYPE_CONVERSION_FLOAT_TO_LONG(long_vars[opcode->operand0], float_vars[opcode->operand1]);
1991 2           break;
1992             }
1993             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_FLOAT_TO_DOUBLE: {
1994 40           SPVM_IMPLEMENT_TYPE_CONVERSION_FLOAT_TO_DOUBLE(double_vars[opcode->operand0], float_vars[opcode->operand1]);
1995 40           break;
1996             }
1997             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_DOUBLE_TO_BYTE: {
1998 2           SPVM_IMPLEMENT_TYPE_CONVERSION_DOUBLE_TO_BYTE(byte_vars[opcode->operand0], double_vars[opcode->operand1]);
1999 2           break;
2000             }
2001             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_DOUBLE_TO_SHORT: {
2002 2           SPVM_IMPLEMENT_TYPE_CONVERSION_DOUBLE_TO_SHORT(short_vars[opcode->operand0], double_vars[opcode->operand1]);
2003 2           break;
2004             }
2005             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_DOUBLE_TO_INT: {
2006 200002           SPVM_IMPLEMENT_TYPE_CONVERSION_DOUBLE_TO_INT(int_vars[opcode->operand0], double_vars[opcode->operand1]);
2007 200002           break;
2008             }
2009             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_DOUBLE_TO_LONG: {
2010 2           SPVM_IMPLEMENT_TYPE_CONVERSION_DOUBLE_TO_LONG(long_vars[opcode->operand0], double_vars[opcode->operand1]);
2011 2           break;
2012             }
2013             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_DOUBLE_TO_FLOAT: {
2014 4           SPVM_IMPLEMENT_TYPE_CONVERSION_DOUBLE_TO_FLOAT(float_vars[opcode->operand0], double_vars[opcode->operand1]);
2015 4           break;
2016             }
2017             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_BYTE_TO_STRING: {
2018 2           SPVM_IMPLEMENT_TYPE_CONVERSION_BYTE_TO_STRING(env, stack, &object_vars[opcode->operand0], byte_vars[opcode->operand1], tmp_buffer, sizeof(tmp_buffer));
2019 2           break;
2020             }
2021             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_SHORT_TO_STRING: {
2022 2           SPVM_IMPLEMENT_TYPE_CONVERSION_SHORT_TO_STRING(env, stack, &object_vars[opcode->operand0], short_vars[opcode->operand1], tmp_buffer, sizeof(tmp_buffer));
2023 2           break;
2024             }
2025             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_INT_TO_STRING: {
2026 828           SPVM_IMPLEMENT_TYPE_CONVERSION_INT_TO_STRING(env, stack, &object_vars[opcode->operand0], int_vars[opcode->operand1], tmp_buffer, sizeof(tmp_buffer));
2027 828           break;
2028             }
2029             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_LONG_TO_STRING: {
2030 2           SPVM_IMPLEMENT_TYPE_CONVERSION_LONG_TO_STRING(env, stack, &object_vars[opcode->operand0], long_vars[opcode->operand1], tmp_buffer, sizeof(tmp_buffer));
2031 2           break;
2032             }
2033             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_FLOAT_TO_STRING: {
2034 26           SPVM_IMPLEMENT_TYPE_CONVERSION_FLOAT_TO_STRING(env, stack, &object_vars[opcode->operand0], float_vars[opcode->operand1], tmp_buffer, sizeof(tmp_buffer));
2035 26           break;
2036             }
2037             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_DOUBLE_TO_STRING: {
2038 26           SPVM_IMPLEMENT_TYPE_CONVERSION_DOUBLE_TO_STRING(env, stack, &object_vars[opcode->operand0], double_vars[opcode->operand1], tmp_buffer, sizeof(tmp_buffer));
2039 26           break;
2040             }
2041             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_STRING_TO_BYTE_ARRAY: {
2042 15           void* src_string = object_vars[opcode->operand1];
2043 15           SPVM_IMPLEMENT_TYPE_CONVERSION_STRING_TO_BYTE_ARRAY(env, stack, &object_vars[opcode->operand0], src_string);
2044 15           break;
2045             }
2046             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_BYTE_ARRAY_TO_STRING: {
2047 11           void* src_byte_array = object_vars[opcode->operand1];
2048 11           SPVM_IMPLEMENT_TYPE_CONVERSION_BYTE_ARRAY_TO_STRING(env, stack, &object_vars[opcode->operand0], src_byte_array);
2049 11           break;
2050             }
2051             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_BYTE_TO_BYTE_OBJECT: {
2052 15           int8_t value = byte_vars[opcode->operand1];
2053 15           SPVM_IMPLEMENT_TYPE_CONVERSION_BYTE_TO_BYTE_OBJECT(env, stack, &object_vars[opcode->operand0], value, object_data_offset);
2054 15           break;
2055             }
2056             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_SHORT_TO_SHORT_OBJECT: {
2057 8           int16_t value = short_vars[opcode->operand1];
2058 8           SPVM_IMPLEMENT_TYPE_CONVERSION_SHORT_TO_SHORT_OBJECT(env, stack, &object_vars[opcode->operand0], value, object_data_offset);
2059 8           break;
2060             }
2061             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_INT_TO_INT_OBJECT: {
2062 193           int32_t value = int_vars[opcode->operand1];
2063 193           SPVM_IMPLEMENT_TYPE_CONVERSION_INT_TO_INT_OBJECT(env, stack, &object_vars[opcode->operand0], value, object_data_offset);
2064 193           break;
2065             }
2066             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_LONG_TO_LONG_OBJECT: {
2067 34           int64_t value = long_vars[opcode->operand1];
2068 34           SPVM_IMPLEMENT_TYPE_CONVERSION_LONG_TO_LONG_OBJECT(env, stack, &object_vars[opcode->operand0], value, object_data_offset);
2069 34           break;
2070             }
2071             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_FLOAT_TO_FLOAT_OBJECT: {
2072 10           float value = float_vars[opcode->operand1];
2073 10           SPVM_IMPLEMENT_TYPE_CONVERSION_FLOAT_TO_FLOAT_OBJECT(env, stack, &object_vars[opcode->operand0], value, object_data_offset);
2074 10           break;
2075             }
2076             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_DOUBLE_TO_DOUBLE_OBJECT: {
2077 23           double value = double_vars[opcode->operand1];
2078 23           SPVM_IMPLEMENT_TYPE_CONVERSION_DOUBLE_TO_DOUBLE_OBJECT(env, stack, &object_vars[opcode->operand0], value, object_data_offset);
2079 23           break;
2080             }
2081             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_BYTE_OBJECT_TO_BYTE: {
2082 11           void* object = object_vars[opcode->operand1];
2083 11           SPVM_IMPLEMENT_TYPE_CONVERSION_BYTE_OBJECT_TO_BYTE(env, stack, &byte_vars[opcode->operand0], object, &error_id, object_data_offset);
2084 11           break;
2085             }
2086             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_SHORT_OBJECT_TO_SHORT: {
2087 11           void* object = object_vars[opcode->operand1];
2088 11           SPVM_IMPLEMENT_TYPE_CONVERSION_SHORT_OBJECT_TO_SHORT(env, stack, &short_vars[opcode->operand0], object, &error_id, object_data_offset);
2089 11           break;
2090             }
2091             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_INT_OBJECT_TO_INT: {
2092 79           void* object = object_vars[opcode->operand1];
2093 79           SPVM_IMPLEMENT_TYPE_CONVERSION_INT_OBJECT_TO_INT(env, stack, &int_vars[opcode->operand0], object, &error_id, object_data_offset);
2094 79           break;
2095             }
2096             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_LONG_OBJECT_TO_LONG: {
2097 11           void* object = object_vars[opcode->operand1];
2098 11           SPVM_IMPLEMENT_TYPE_CONVERSION_LONG_OBJECT_TO_LONG(env, stack, &long_vars[opcode->operand0], object, &error_id, object_data_offset);
2099 11           break;
2100             }
2101             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_FLOAT_OBJECT_TO_FLOAT: {
2102 11           void* object = object_vars[opcode->operand1];
2103 11           SPVM_IMPLEMENT_TYPE_CONVERSION_FLOAT_OBJECT_TO_FLOAT(env, stack, &float_vars[opcode->operand0], object, &error_id, object_data_offset);
2104 11           break;
2105             }
2106             case SPVM_OPCODE_C_ID_TYPE_CONVERSION_DOUBLE_OBJECT_TO_DOUBLE: {
2107 11           void* object = object_vars[opcode->operand1];
2108 11           SPVM_IMPLEMENT_TYPE_CONVERSION_DOUBLE_OBJECT_TO_DOUBLE(env, stack, &double_vars[opcode->operand0], object, &error_id, object_data_offset);
2109 11           break;
2110             }
2111             case SPVM_OPCODE_C_ID_GET_STACK_BYTE: {
2112 477           SPVM_IMPLEMENT_GET_STACK_BYTE(byte_vars[opcode->operand0], stack, opcode->operand3 & 0xFF);
2113 477           break;
2114             }
2115             case SPVM_OPCODE_C_ID_GET_STACK_SHORT: {
2116 27           SPVM_IMPLEMENT_GET_STACK_SHORT(short_vars[opcode->operand0], stack, opcode->operand3 & 0xFF);
2117 27           break;
2118             }
2119             case SPVM_OPCODE_C_ID_GET_STACK_INT: {
2120 1724537           SPVM_IMPLEMENT_GET_STACK_INT(int_vars[opcode->operand0], stack, opcode->operand3 & 0xFF);
2121 1724537           break;
2122             }
2123             case SPVM_OPCODE_C_ID_GET_STACK_LONG: {
2124 1996           SPVM_IMPLEMENT_GET_STACK_LONG(long_vars[opcode->operand0], stack, opcode->operand3 & 0xFF);
2125 1996           break;
2126             }
2127             case SPVM_OPCODE_C_ID_GET_STACK_FLOAT: {
2128 1218           SPVM_IMPLEMENT_GET_STACK_FLOAT(float_vars[opcode->operand0], stack, opcode->operand3 & 0xFF);
2129 1218           break;
2130             }
2131             case SPVM_OPCODE_C_ID_GET_STACK_DOUBLE: {
2132 301422           SPVM_IMPLEMENT_GET_STACK_DOUBLE(double_vars[opcode->operand0], stack, opcode->operand3 & 0xFF);
2133 301422           break;
2134             }
2135             case SPVM_OPCODE_C_ID_GET_STACK_OBJECT: {
2136 524037           SPVM_IMPLEMENT_GET_STACK_OBJECT(env, &object_vars[opcode->operand0], stack, opcode->operand3 & 0xFF);
2137 524037           break;
2138             }
2139             case SPVM_OPCODE_C_ID_GET_STACK_REF: {
2140 600045           SPVM_IMPLEMENT_GET_STACK_REF(ref_vars[opcode->operand0], stack, opcode->operand3 & 0xFF);
2141 600045           break;
2142             }
2143             case SPVM_OPCODE_C_ID_GET_STACK_MULNUM_BYTE: {
2144 11           int32_t args_width = opcode->operand3 >> 8;
2145 11           SPVM_IMPLEMENT_GET_STACK_MULNUM_BYTE(env, &byte_vars[opcode->operand0], stack, opcode->operand3 & 0xFF, args_width);
2146 11           break;
2147             }
2148             case SPVM_OPCODE_C_ID_GET_STACK_MULNUM_SHORT: {
2149 10           int32_t args_width = opcode->operand3 >> 8;
2150 10           SPVM_IMPLEMENT_GET_STACK_MULNUM_SHORT(env, &short_vars[opcode->operand0], stack, opcode->operand3 & 0xFF, args_width);
2151 10           break;
2152             }
2153             case SPVM_OPCODE_C_ID_GET_STACK_MULNUM_INT: {
2154 10           int32_t args_width = opcode->operand3 >> 8;
2155 10           SPVM_IMPLEMENT_GET_STACK_MULNUM_INT(env, &int_vars[opcode->operand0], stack, opcode->operand3 & 0xFF, args_width);
2156 10           break;
2157             }
2158             case SPVM_OPCODE_C_ID_GET_STACK_MULNUM_LONG: {
2159 10           int32_t args_width = opcode->operand3 >> 8;
2160 10           SPVM_IMPLEMENT_GET_STACK_MULNUM_LONG(env, &long_vars[opcode->operand0], stack, opcode->operand3 & 0xFF, args_width);
2161 10           break;
2162             }
2163             case SPVM_OPCODE_C_ID_GET_STACK_MULNUM_FLOAT: {
2164 10           int32_t args_width = opcode->operand3 >> 8;
2165 10           SPVM_IMPLEMENT_GET_STACK_MULNUM_FLOAT(env, &float_vars[opcode->operand0], stack, opcode->operand3 & 0xFF, args_width);
2166 10           break;
2167             }
2168             case SPVM_OPCODE_C_ID_GET_STACK_MULNUM_DOUBLE: {
2169 13           int32_t args_width = opcode->operand3 >> 8;
2170 13           SPVM_IMPLEMENT_GET_STACK_MULNUM_DOUBLE(env, &double_vars[opcode->operand0], stack, opcode->operand3 & 0xFF, args_width);
2171 13           break;
2172             }
2173             case SPVM_OPCODE_C_ID_GET_STACK_OPTIONAL_BYTE: {
2174 4           int32_t stack_index = opcode->operand3 & 0xFF;
2175 4           SPVM_IMPLEMENT_GET_STACK_OPTIONAL_BYTE(env, &byte_vars[opcode->operand0], stack, stack_index, (int8_t)(uint8_t)opcode->operand1);
2176 4           break;
2177             }
2178             case SPVM_OPCODE_C_ID_GET_STACK_OPTIONAL_SHORT: {
2179 4           int32_t stack_index = opcode->operand3 & 0xFF;
2180 4           SPVM_IMPLEMENT_GET_STACK_OPTIONAL_SHORT(env, &short_vars[opcode->operand0], stack, stack_index, (int16_t)(uint16_t)opcode->operand1);
2181 4           break;
2182             }
2183             case SPVM_OPCODE_C_ID_GET_STACK_OPTIONAL_INT: {
2184 645657           int32_t stack_index = opcode->operand3 & 0xFF;
2185 645657           SPVM_IMPLEMENT_GET_STACK_OPTIONAL_INT(env, &int_vars[opcode->operand0], stack, stack_index, (int32_t)opcode->operand1);
2186 645657           break;
2187             }
2188             case SPVM_OPCODE_C_ID_GET_STACK_OPTIONAL_LONG: {
2189 5           int32_t stack_index = opcode->operand3 & 0xFF;
2190 5           SPVM_IMPLEMENT_GET_STACK_OPTIONAL_LONG(env, &long_vars[opcode->operand0], stack, stack_index, *(int64_t*)&opcode->operand1);
2191 5           break;
2192             }
2193             case SPVM_OPCODE_C_ID_GET_STACK_OPTIONAL_FLOAT: {
2194 2           int32_t stack_index = opcode->operand3 & 0xFF;
2195             SPVM_VALUE default_value;
2196 2           default_value.ival = (int32_t)opcode->operand1;
2197 2           SPVM_IMPLEMENT_GET_STACK_OPTIONAL_FLOAT(env, &float_vars[opcode->operand0], stack, stack_index, default_value.fval);
2198 2           break;
2199             }
2200             case SPVM_OPCODE_C_ID_GET_STACK_OPTIONAL_DOUBLE: {
2201 2           int32_t stack_index = opcode->operand3 & 0xFF;
2202 2           SPVM_IMPLEMENT_GET_STACK_OPTIONAL_DOUBLE(env, &double_vars[opcode->operand0], stack, stack_index, *(double*)&opcode->operand1);
2203 2           break;
2204             }
2205             case SPVM_OPCODE_C_ID_GET_STACK_OPTIONAL_OBJECT: {
2206 18389           int32_t stack_index = opcode->operand3 & 0xFF;
2207 18389           SPVM_IMPLEMENT_GET_STACK_OPTIONAL_OBJECT(env, &object_vars[opcode->operand0], stack, stack_index);
2208 18389           break;
2209             }
2210             case SPVM_OPCODE_C_ID_END_ARGS: {
2211             // Do nothing
2212 1457635           break;
2213             }
2214             case SPVM_OPCODE_C_ID_SET_STACK_BYTE: {
2215 457           SPVM_IMPLEMENT_SET_STACK_BYTE(stack, opcode->operand3, byte_vars[opcode->operand0]);
2216 457           break;
2217             }
2218             case SPVM_OPCODE_C_ID_SET_STACK_SHORT: {
2219 7           SPVM_IMPLEMENT_SET_STACK_SHORT(stack, opcode->operand3, short_vars[opcode->operand0]);
2220 7           break;
2221             }
2222             case SPVM_OPCODE_C_ID_SET_STACK_INT: {
2223 503578           SPVM_IMPLEMENT_SET_STACK_INT(stack, opcode->operand3, int_vars[opcode->operand0]);
2224 503578           break;
2225             }
2226             case SPVM_OPCODE_C_ID_SET_STACK_LONG: {
2227 288           SPVM_IMPLEMENT_SET_STACK_LONG(stack, opcode->operand3, long_vars[opcode->operand0]);
2228 288           break;
2229             }
2230             case SPVM_OPCODE_C_ID_SET_STACK_FLOAT: {
2231 283           SPVM_IMPLEMENT_SET_STACK_FLOAT(stack, opcode->operand3, float_vars[opcode->operand0]);
2232 283           break;
2233             }
2234             case SPVM_OPCODE_C_ID_SET_STACK_DOUBLE: {
2235 285           SPVM_IMPLEMENT_SET_STACK_DOUBLE(stack, opcode->operand3, double_vars[opcode->operand0]);
2236 285           break;
2237             }
2238             case SPVM_OPCODE_C_ID_SET_STACK_OBJECT: {
2239 646894           SPVM_IMPLEMENT_SET_STACK_OBJECT(stack, opcode->operand3, object_vars[opcode->operand0]);
2240 646894           break;
2241             }
2242             case SPVM_OPCODE_C_ID_SET_STACK_REF: {
2243 1000249           SPVM_IMPLEMENT_SET_STACK_REF(stack, opcode->operand3, ref_vars[opcode->operand0]);
2244 1000249           break;
2245             }
2246             case SPVM_OPCODE_C_ID_SET_STACK_UNDEF: {
2247 257           SPVM_IMPLEMENT_SET_STACK_UNDEF(stack, opcode->operand3);
2248 257           break;
2249             }
2250             case SPVM_OPCODE_C_ID_SET_STACK_MULNUM_BYTE: {
2251 3           int32_t fields_length = opcode->operand1;
2252 3           SPVM_IMPLEMENT_SET_STACK_MULNUM_BYTE(env, stack, opcode->operand3, fields_length, &byte_vars[opcode->operand0]);
2253 3           break;
2254             }
2255             case SPVM_OPCODE_C_ID_SET_STACK_MULNUM_SHORT: {
2256 3           int32_t fields_length = opcode->operand1;
2257 3           SPVM_IMPLEMENT_SET_STACK_MULNUM_SHORT(env, stack, opcode->operand3, fields_length, &short_vars[opcode->operand0]);
2258 3           break;
2259             }
2260             case SPVM_OPCODE_C_ID_SET_STACK_MULNUM_INT: {
2261 3           int32_t fields_length = opcode->operand1;
2262 3           SPVM_IMPLEMENT_SET_STACK_MULNUM_INT(env, stack, opcode->operand3, fields_length, &int_vars[opcode->operand0]);
2263 3           break;
2264             }
2265             case SPVM_OPCODE_C_ID_SET_STACK_MULNUM_LONG: {
2266 3           int32_t fields_length = opcode->operand1;
2267 3           SPVM_IMPLEMENT_SET_STACK_MULNUM_LONG(env, stack, opcode->operand3, fields_length, &long_vars[opcode->operand0]);
2268 3           break;
2269             }
2270             case SPVM_OPCODE_C_ID_SET_STACK_MULNUM_FLOAT: {
2271 3           int32_t fields_length = opcode->operand1;
2272 3           SPVM_IMPLEMENT_SET_STACK_MULNUM_FLOAT(env, stack, opcode->operand3, fields_length, &float_vars[opcode->operand0]);
2273 3           break;
2274             }
2275             case SPVM_OPCODE_C_ID_SET_STACK_MULNUM_DOUBLE: {
2276 7           int32_t fields_length = opcode->operand1;
2277 7           SPVM_IMPLEMENT_SET_STACK_MULNUM_DOUBLE(env, stack, opcode->operand3, fields_length, &double_vars[opcode->operand0]);
2278 7           break;
2279             }
2280             case SPVM_OPCODE_C_ID_RETURN_VOID: {
2281 131935           opcode_rel_index = opcode->operand1;
2282 131935           continue;
2283             }
2284             case SPVM_OPCODE_C_ID_RETURN_BYTE: {
2285 16           SPVM_IMPLEMENT_RETURN_BYTE(stack, byte_vars[opcode->operand0]);
2286 16           opcode_rel_index = opcode->operand1;
2287 16           continue;
2288             }
2289             case SPVM_OPCODE_C_ID_RETURN_SHORT: {
2290 20           SPVM_IMPLEMENT_RETURN_SHORT(stack, short_vars[opcode->operand0]);
2291 20           opcode_rel_index = opcode->operand1;
2292 20           continue;
2293             }
2294             case SPVM_OPCODE_C_ID_RETURN_INT: {
2295 634269           SPVM_IMPLEMENT_RETURN_INT(stack, int_vars[opcode->operand0]);
2296 634269           opcode_rel_index = opcode->operand1;
2297 634269           continue;
2298             }
2299             case SPVM_OPCODE_C_ID_RETURN_LONG: {
2300 1111           SPVM_IMPLEMENT_RETURN_LONG(stack, long_vars[opcode->operand0]);
2301 1111           opcode_rel_index = opcode->operand1;
2302 1111           continue;
2303             }
2304             case SPVM_OPCODE_C_ID_RETURN_FLOAT: {
2305 581           SPVM_IMPLEMENT_RETURN_FLOAT(stack, float_vars[opcode->operand0]);
2306 581           opcode_rel_index = opcode->operand1;
2307 581           continue;
2308             }
2309             case SPVM_OPCODE_C_ID_RETURN_DOUBLE: {
2310 600802           SPVM_IMPLEMENT_RETURN_DOUBLE(stack, double_vars[opcode->operand0]);
2311 600802           opcode_rel_index = opcode->operand1;
2312 600802           continue;
2313             }
2314             case SPVM_OPCODE_C_ID_RETURN_OBJECT: {
2315 88324           SPVM_IMPLEMENT_RETURN_OBJECT(env, stack, object_vars[opcode->operand0]);
2316 88324           opcode_rel_index = opcode->operand1;
2317 88324           continue;
2318             }
2319             case SPVM_OPCODE_C_ID_RETURN_UNDEF: {
2320 7           SPVM_IMPLEMENT_RETURN_UNDEF(stack);
2321 7           opcode_rel_index = opcode->operand1;
2322 7           continue;
2323             }
2324             case SPVM_OPCODE_C_ID_RETURN_MULNUM_BYTE: {
2325 6           int32_t fields_length = opcode->operand2;
2326 6           SPVM_IMPLEMENT_RETURN_MULNUM_BYTE(env, stack, &byte_vars[opcode->operand0], fields_length);
2327 6           opcode_rel_index = opcode->operand1;
2328 6           continue;
2329             }
2330             case SPVM_OPCODE_C_ID_RETURN_MULNUM_SHORT: {
2331 5           int32_t fields_length = opcode->operand2;
2332 5           SPVM_IMPLEMENT_RETURN_MULNUM_SHORT(env, stack, &short_vars[opcode->operand0], fields_length);
2333 5           opcode_rel_index = opcode->operand1;
2334 5           continue;
2335             }
2336             case SPVM_OPCODE_C_ID_RETURN_MULNUM_INT: {
2337 5           int32_t fields_length = opcode->operand2;
2338 5           SPVM_IMPLEMENT_RETURN_MULNUM_INT(env, stack, &int_vars[opcode->operand0], fields_length);
2339 5           opcode_rel_index = opcode->operand1;
2340 5           continue;
2341             }
2342             case SPVM_OPCODE_C_ID_RETURN_MULNUM_LONG: {
2343 5           int32_t fields_length = opcode->operand2;
2344 5           SPVM_IMPLEMENT_RETURN_MULNUM_LONG(env, stack, &long_vars[opcode->operand0], fields_length);
2345 5           opcode_rel_index = opcode->operand1;
2346 5           continue;
2347             }
2348             case SPVM_OPCODE_C_ID_RETURN_MULNUM_FLOAT: {
2349 5           int32_t fields_length = opcode->operand2;
2350 5           SPVM_IMPLEMENT_RETURN_MULNUM_FLOAT(env, stack, &float_vars[opcode->operand0], fields_length);
2351 5           opcode_rel_index = opcode->operand1;
2352 5           continue;
2353             }
2354             case SPVM_OPCODE_C_ID_RETURN_MULNUM_DOUBLE: {
2355 6           int32_t fields_length = opcode->operand2;
2356 6           SPVM_IMPLEMENT_RETURN_MULNUM_DOUBLE(env, stack, &double_vars[opcode->operand0], fields_length);
2357 6           opcode_rel_index = opcode->operand1;
2358 6           continue;
2359             }
2360             case SPVM_OPCODE_C_ID_CALL_CLASS_METHOD: {
2361 1698934           int32_t invocant_decl_basic_type_id = opcode->operand0;
2362 1698934           int32_t decl_method_index = opcode->operand1;
2363 1698934           int32_t args_width = opcode->operand2;
2364            
2365 1698934           SPVM_RUNTIME_BASIC_TYPE* invocant_decl_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, invocant_decl_basic_type_id);
2366            
2367 1698934           SPVM_RUNTIME_METHOD* method = SPVM_API_BASIC_TYPE_get_method_by_index(env->runtime, invocant_decl_basic_type, decl_method_index);
2368            
2369 1698934           SPVM_IMPLEMENT_CALL_CLASS_METHOD(env, stack, error_id, method, args_width);
2370            
2371 1698934           break;
2372             }
2373             case SPVM_OPCODE_C_ID_CALL_INSTANCE_METHOD_STATIC: {
2374 54           int32_t invocant_decl_basic_type_id = opcode->operand0;
2375 54           int32_t decl_method_index = opcode->operand1;
2376 54           int32_t args_width = opcode->operand2;
2377            
2378 54           SPVM_RUNTIME_BASIC_TYPE* invocant_decl_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, invocant_decl_basic_type_id);
2379            
2380 54           SPVM_RUNTIME_METHOD* method = SPVM_API_BASIC_TYPE_get_method_by_index(env->runtime, invocant_decl_basic_type, decl_method_index);
2381            
2382 54           SPVM_IMPLEMENT_CALL_INSTANCE_METHOD_STATIC(env, stack, error_id, method, args_width);
2383 54           break;
2384             }
2385             case SPVM_OPCODE_C_ID_CALL_INSTANCE_METHOD: {
2386 505973           int32_t invocant_decl_basic_type_id = opcode->operand0;
2387 505973           int32_t decl_method_index = opcode->operand1;
2388 505973           int32_t args_width = opcode->operand2;
2389            
2390 505973           SPVM_RUNTIME_BASIC_TYPE* invocant_decl_basic_type = SPVM_API_RUNTIME_get_basic_type_by_id(runtime, invocant_decl_basic_type_id);
2391            
2392 505973           SPVM_RUNTIME_METHOD* method = SPVM_API_BASIC_TYPE_get_method_by_index(runtime, invocant_decl_basic_type, decl_method_index);
2393 505973           const char* method_name = method->name;
2394            
2395 505973           const char* basic_type_name = method->current_basic_type->name;
2396            
2397 505973           SPVM_IMPLEMENT_CALL_INSTANCE_METHOD(env, stack, basic_type_name, method_name, args_width, &error_id, tmp_buffer, sizeof(tmp_buffer));
2398 505973           break;
2399             }
2400             }
2401 31211506           opcode_rel_index++;
2402 34123313           }
2403            
2404             label_END_OF_METHOD: {
2405            
2406 1457635 100         if (error_id == 0) {
2407 1457097           SPVM_RUNTIME_BASIC_TYPE* current_method_return_basic_type = current_method->return_basic_type;
2408 1457097           int32_t current_method_return_type_dimension = current_method->return_type_dimension;
2409 1457097           int32_t current_method_return_type_flag =current_method->return_type_flag;
2410 1457097           int32_t method_return_type_is_object = SPVM_API_TYPE_is_object_type(runtime, current_method_return_basic_type, current_method_return_type_dimension, current_method_return_type_flag);
2411 1457097 100         if (method_return_type_is_object) {
2412 88331 100         if (*(void**)&stack[0] != NULL) {
2413 87923           env->api->internal->lock_object(env, stack, *(void**)&stack[0]);
2414 87923           env->api->internal->dec_ref_count(env, stack, *(void**)&stack[0]);
2415 87923           env->api->internal->unlock_object(env, stack, *(void**)&stack[0]);
2416             }
2417             }
2418             }
2419            
2420 1457635           SPVM_API_free_memory_stack(env, stack, call_stack);
2421 1457635           call_stack = NULL;
2422            
2423 1457635           return error_id;
2424             }
2425             }