1 /* This code is machine-generated. See its source for license
2 information. This software is derived from software
3 distributed under the GNU GPL version 3 or later. */
4
5 /* User-specified code, initial vm1 part: beginning. */
6 #line 157 "../../libpoke/pvm.jitter"
7 #line 157 "../../libpoke/pvm.jitter"
8
9 # include <config.h>
10
11 /* User-specified code, initial vm1 part: end */
12
13 /* VM library: main VM C file template.
14
15 Copyright (C) 2016, 2017, 2018, 2019, 2020 Luca Saiu
16 Written by Luca Saiu
17
18 This file is part of Jitter.
19
20 Jitter is free software: you can redistribute it and/or modify
21 it under the terms of the GNU General Public License as published by
22 the Free Software Foundation, either version 3 of the License, or
23 (at your option) any later version.
24
25 Jitter is distributed in the hope that it will be useful,
26 but WITHOUT ANY WARRANTY; without even the implied warranty of
27 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 GNU General Public License for more details.
29
30 You should have received a copy of the GNU General Public License
31 along with Jitter. If not, see <http://www.gnu.org/licenses/>. */
32
33
34 /* Generated file warning.
35 * ************************************************************************** */
36
37 /* Unless this file is named exactly "vm1.c" , without any prefix, you are
38 looking at a machine-generated derived file. The original source is the vm.c
39 template from Jitter, with added code implementing the pvm VM. */
40
41
42
43
44 #include <assert.h>
45 #include <string.h>
46
47 #include <jitter/jitter.h>
48
49 #if defined (JITTER_PROFILE_SAMPLE)
50 #include <sys/time.h>
51 #endif // #if defined (JITTER_PROFILE_SAMPLE)
52
53 #include <jitter/jitter-hash.h>
54 #include <jitter/jitter-instruction.h>
55 #include <jitter/jitter-mmap.h>
56 #include <jitter/jitter-mutable-routine.h>
57 #include <jitter/jitter-print.h>
58 #include <jitter/jitter-rewrite.h>
59 #include <jitter/jitter-routine.h>
60 #include <jitter/jitter-routine-parser.h>
61 #include <jitter/jitter-specialize.h>
62 #include <jitter/jitter-defect.h>
63 #include <jitter/jitter-patch-in.h>
64
65 /* I don't need to include <jitter/jitter-executor.h> here, nor to define
66 JITTER_THIS_CAN_INCLUDE_JITTER_EXECUTOR_H ; doing so carelessly might
67 lead to subtle bugs, that it is better to prevent.
68 Of course I can reconsider this decision in the future. */
69
70 #include <jitter/jitter-data-locations.h>
71
72 #include "pvm-vm.h"
73 //#include "pvm-specialized-instructions.h"
74 //#include "pvm-meta-instructions.h"
75 #include <jitter/jitter-fatal.h>
76
77
78
79
80 /* Check requirements for particular features.
81 * ************************************************************************** */
82
83 /* VM sample-profiling is only supported with GCC. Do not bother activating it
84 with other compilers, if the numbers are unreliable in the end. */
85 #if defined (JITTER_PROFILE_SAMPLE) \
86 && ! defined (JITTER_HAVE_ACTUAL_GCC)
87 # error "Sample-profiling is only reliable with GCC: it requires (machine-independent)"
88 # error "GNU C extended asm, and it is not worth supporting other compilers if"
89 # error "the numbers turn out to be unreliable in the end."
90 #endif
91
92
93
94
95 /* Machine-generated data structures.
96 * ************************************************************************** */
97
98 /* Machine-generated data structures defining this VM. Initializing a static
99 struct is problematic, as it requires constant expressions for each field --
100 and const pointers don't qualify. This is why we initialize the struct
101 fields below in pvm_initialize. */
102 static struct jitter_vm
103 the_pvm_vm;
104
105 struct jitter_vm * const
106 pvm_vm = & the_pvm_vm;
107
108 struct jitter_list_header * const
109 pvm_states = & the_pvm_vm.states;
110
111 /* It is convenient to have this initialised at start up, even before calling
112 any initialisation function. This makes it reliable to read this when, for
113 example, handling --version . */
114 static const struct jitter_vm_configuration
115 pvm_vm_the_configuration
116 = {
117 PVM_LOWER_CASE_PREFIX /* lower_case_prefix */,
118 PVM_UPPER_CASE_PREFIX /* upper_case_prefix */,
119 PVM_MAX_FAST_REGISTER_NO_PER_CLASS
120 /* max_fast_register_no_per_class */,
121 PVM_MAX_NONRESIDUAL_LITERAL_NO /* max_nonresidual_literal_no */,
122 PVM_DISPATCH_HUMAN_READABLE /* dispatch_human_readable */,
123 /* The instrumentation field can be seen as a bit map. See the comment
124 in jitter/jitter-vm.h . */
125 (jitter_vm_instrumentation_none
126 #if defined (JITTER_PROFILE_COUNT)
127 | jitter_vm_instrumentation_count
128 #endif
129 #if defined (JITTER_PROFILE_SAMPLE)
130 | jitter_vm_instrumentation_sample
131 #endif
132 ) /* instrumentation */
133 };
134
135 const struct jitter_vm_configuration * const
136 pvm_vm_configuration
137 = & pvm_vm_the_configuration;
138
139
140
141
142 /* Initialization and finalization: internal functions, not for the user.
143 * ************************************************************************** */
144
145 /* Initialize threads. This only needs to be called once at initialization, and
146 the user doesn't need to bother with it. Defined along with the executor. */
147 void
148 pvm_initialize_threads (void);
149
150 /* Check that the encodings in enum jitter_specialized_instruction_opcode (as
151 used in the specializer) are coherent with machine-generated code. Making a
152 mistake here would introduce subtle bugs, so it's better to be defensive. */
153 static void
pvm_check_specialized_instruction_opcode_once(void)154 pvm_check_specialized_instruction_opcode_once (void)
155 {
156 static bool already_checked = false;
157 if (already_checked)
158 return;
159
160 assert (((enum jitter_specialized_instruction_opcode)
161 pvm_specialized_instruction_opcode__eINVALID)
162 == jitter_specialized_instruction_opcode_INVALID);
163 assert (((enum jitter_specialized_instruction_opcode)
164 pvm_specialized_instruction_opcode__eBEGINBASICBLOCK)
165 == jitter_specialized_instruction_opcode_BEGINBASICBLOCK);
166 assert (((enum jitter_specialized_instruction_opcode)
167 pvm_specialized_instruction_opcode__eEXITVM)
168 == jitter_specialized_instruction_opcode_EXITVM);
169 assert (((enum jitter_specialized_instruction_opcode)
170 pvm_specialized_instruction_opcode__eDATALOCATIONS)
171 == jitter_specialized_instruction_opcode_DATALOCATIONS);
172 assert (((enum jitter_specialized_instruction_opcode)
173 pvm_specialized_instruction_opcode__eNOP)
174 == jitter_specialized_instruction_opcode_NOP);
175 assert (((enum jitter_specialized_instruction_opcode)
176 pvm_specialized_instruction_opcode__eUNREACHABLE0)
177 == jitter_specialized_instruction_opcode_UNREACHABLE0);
178 assert (((enum jitter_specialized_instruction_opcode)
179 pvm_specialized_instruction_opcode__eUNREACHABLE1)
180 == jitter_specialized_instruction_opcode_UNREACHABLE1);
181 assert (((enum jitter_specialized_instruction_opcode)
182 pvm_specialized_instruction_opcode__eUNREACHABLE2)
183 == jitter_specialized_instruction_opcode_UNREACHABLE2);
184
185 already_checked = true;
186 }
187
188 /* A prototype for a machine-generated function not needing a public
189 declaration, only called thru a pointer within struct jitter_vm . */
190 int
191 pvm_specialize_instruction (struct jitter_mutable_routine *p,
192 const struct jitter_instruction *ins);
193
194 /* Initialize the pointed special-purpose data structure. */
195 static void
pvm_initialize_special_purpose_data(volatile struct jitter_special_purpose_state_data * d)196 pvm_initialize_special_purpose_data
197 (volatile struct jitter_special_purpose_state_data *d)
198 {
199 d->pending_notifications = 0;
200 jitter_initialize_pending_signal_notifications
201 (& d->pending_signal_notifications);
202
203 /* Initialise profiling fields. */
204 jitter_profile_runtime_initialize (pvm_vm,
205 (struct jitter_profile_runtime *)
206 & d->profile_runtime);
207 }
208
209 /* Finalize the pointed special-purpose data structure. */
210 static void
pvm_finalize_special_purpose_data(volatile struct jitter_special_purpose_state_data * d)211 pvm_finalize_special_purpose_data
212 (volatile struct jitter_special_purpose_state_data *d)
213 {
214 jitter_finalize_pending_signal_notifications
215 (d->pending_signal_notifications);
216
217 jitter_profile_runtime_finalize (pvm_vm,
218 (struct jitter_profile_runtime *)
219 & d->profile_runtime);
220 }
221
222
223
224
225 /* Check that we link with the correct Jitter library.
226 * ************************************************************************** */
227
228 /* It is possible to make a mistake at link time, and link a VM compiled with
229 some threading model with the Jitter runtime for a different model. That
230 would cause crashes, that is better to prevent. This is a way to detect such
231 mistakes very early, by causing a link-time failure in case of mismatch. */
232 extern volatile const bool
233 JITTER_DISPATCH_DEPENDENT_GLOBAL_NAME;
234
235
236
237
238 /* Low-level debugging features relying on assembly: data locations.
239 * ************************************************************************** */
240
241 #if defined (JITTER_HAVE_KNOWN_BINARY_FORMAT) && ! defined (JITTER_DISPATCH_SWITCH)
242 /* A declaration for data locations, as visible from C. The global is defined in
243 assembly in its own separate section thru the machinery in
244 jitter/jitter-sections.h . */
245 extern const char
246 JITTER_DATA_LOCATION_NAME(pvm) [];
247 #endif // #if ...
248
249 void
pvm_dump_data_locations(jitter_print_context output)250 pvm_dump_data_locations (jitter_print_context output)
251 {
252 #ifndef JITTER_DISPATCH_SWITCH
253 jitter_dump_data_locations (output, & the_pvm_vm);
254 #else
255 jitter_print_char_star (output,
256 "VM data location information unavailable\n");
257 #endif // #ifndef JITTER_DISPATCH_SWITCH
258 }
259
260
261
262
263 /* Initialization and finalization.
264 * ************************************************************************** */
265
266 #ifdef JITTER_HAVE_PATCH_IN
267 JITTER_DEFECT_DESCRIPTOR_DECLARATIONS_(pvm)
268 JITTER_PATCH_IN_DESCRIPTOR_DECLARATIONS_(pvm)
269 #endif // #ifdef JITTER_HAVE_PATCH_IN
270
271 #ifndef JITTER_DISPATCH_SWITCH
272 /* True iff thread sizes are all non-negative and non-huge. We refuse to
273 disassemble otherwise, and when replication is enabled we refuse to run
274 altogether. See the comment right below. */
275 static bool
276 pvm_threads_validated = false;
277 #endif // #ifndef JITTER_DISPATCH_SWITCH
278
279 /* Omit pvm_validate_thread_sizes_once for switch-dispatching, as threads
280 don't exist at all in that case.*/
281 #ifndef JITTER_DISPATCH_SWITCH
282 /* Check that VM instruction sizes are all non-negative, and that no thread
283 starts before the end of the previous one. Even one violation of such
284 conditions is a symptom that the code has not been compiled with
285 -fno-reorder-blocks , which would have disastrous effects with replication.
286 It's better to validate threads at startup and fail immediately than to crash
287 at run time.
288
289 If even one thread appears to be wrong then refuse to disassemble when
290 replication is disabled, and refuse to run altogether if replication is
291 enabled. */
292 static void
pvm_validate_threads_once(void)293 pvm_validate_threads_once (void)
294 {
295 /* Return if this is not the first time we got here. */
296 static bool already_validated = false;
297 if (already_validated)
298 return;
299
300 #ifdef JITTER_REPLICATE
301 # define JITTER_FAIL(error_text) \
302 do \
303 { \
304 fprintf (stderr, \
305 "About specialized instruction %i (%s) at %p, size %liB\n", \
306 i, pvm_specialized_instruction_names [i], \
307 pvm_threads [i], \
308 pvm_thread_sizes [i]); \
309 jitter_fatal ("%s: you are not compiling with -fno-reorder-blocks", \
310 error_text); \
311 } \
312 while (false)
313 #else
314 # define JITTER_FAIL(ignored_error_text) \
315 do \
316 { \
317 everything_valid = false; \
318 goto out; \
319 } \
320 while (false)
321 #endif // #ifdef JITTER_REPLICATE
322
323 /* The minimum address the next instruction code has to start at.
324
325 This relies on NULL being zero, or in general lower in magnitude than any
326 valid pointer. It is not worth the trouble to be pedantic, as this will be
327 true on every architecture where I can afford low-level tricks. */
328 jitter_thread lower_bound = NULL;
329
330 /* Check every thread. We rely on the order here, following specialized
331 instruction opcodes. */
332 int i;
333 bool everything_valid = true;
334 for (i = 0; i < PVM_SPECIALIZED_INSTRUCTION_NO; i ++)
335 {
336 jitter_thread thread = pvm_threads [i];
337 long size = pvm_thread_sizes [i];
338
339 /* Check that the current thread has non-negative non-huge size and
340 doesn't start before the end of the previous one. If this is true for
341 all threads we can conclude that they are non-overlapping as well. */
342 if (__builtin_expect (size < 0, false))
343 JITTER_FAIL("a specialized instruction has negative code size");
344 if (__builtin_expect (size > (1 << 24), false))
345 JITTER_FAIL("a specialized instruction has huge code size");
346 if (__builtin_expect (lower_bound > thread, false))
347 JITTER_FAIL("non-sequential thread");
348
349 /* The next thread cannot start before the end of the current one. */
350 lower_bound = ((char*) thread) + size;
351 }
352
353 #undef JITTER_FAIL
354
355 #ifndef JITTER_REPLICATE
356 out:
357 #endif // #ifndef JITTER_REPLICATE
358
359 /* If we have validated every thread size then disassembling appears safe. */
360 if (everything_valid)
361 pvm_threads_validated = true;
362
363 /* We have checked the thread sizes, once and for all. If this function gets
364 called again, thru a second pvm initialization, it will immediately
365 return. */
366 already_validated = true;
367 }
368 #endif // #ifndef JITTER_DISPATCH_SWITCH
369
370 #ifdef JITTER_HAVE_PATCH_IN
371 /* The actual defect table. We only need it when patch-ins are in use. */
372 jitter_uint
373 pvm_defect_table [PVM_SPECIALIZED_INSTRUCTION_NO];
374 #endif // #ifdef JITTER_HAVE_PATCH_IN
375
376 void
pvm_initialize(void)377 pvm_initialize (void)
378 {
379 /* Check that the Jitter library we linked is the right one. This check
380 actually only useful to force the global to be used. I prefer not to use
381 an assert, because assertions can be disabled. */
382 if (! JITTER_DISPATCH_DEPENDENT_GLOBAL_NAME)
383 jitter_fatal ("impossible to reach: the thing should fail at link time");
384
385 #ifdef JITTER_REPLICATE
386 /* Initialize the executable-memory subsystem. */
387 jitter_initialize_executable ();
388 #endif // #ifdef JITTER_REPLICATE
389
390 /* Initialise the print-context machinery. */
391 jitter_print_initialize ();
392
393 /* Perform some sanity checks which only need to be run once. */
394 pvm_check_specialized_instruction_opcode_once ();
395
396 /* We have to initialize threads before pvm_threads , since the struct
397 needs threads. */
398 pvm_initialize_threads ();
399
400 #ifndef JITTER_DISPATCH_SWITCH
401 /* Validate threads, to make sure the generated code was not compiled with
402 incorrect options. This only needs to be done once. */
403 pvm_validate_threads_once ();
404 #endif // ifndef JITTER_DISPATCH_SWITCH
405
406 /* Initialize the object pointed by pvm_vm (see the comment above as to
407 why we do it here). Before actually setting the fields to valid data, fill
408 the whole struct with a -- hopefully -- invalid pattern, just to catch
409 bugs. */
410 static bool vm_struct_initialized = false;
411 if (! vm_struct_initialized)
412 {
413 memset (& the_pvm_vm, 0xff, sizeof (struct jitter_vm));
414
415 /* Make the configuration struct reachable from the VM struct. */
416 the_pvm_vm.configuration = pvm_vm_configuration;
417 //pvm_print_vm_configuration (stdout, & the_pvm_vm.configuration);
418
419 /* Initialize meta-instruction pointers for implicit instructions.
420 VM-independent program specialization relies on those, so they have to
421 be accessible to the Jitter library, out of generated code. Since
422 meta-instructions are sorted alphabetically in the array, the index
423 is not fixed. */
424 the_pvm_vm.exitvm_meta_instruction
425 = (pvm_meta_instructions + pvm_meta_instruction_id_exitvm);
426 the_pvm_vm.unreachable_meta_instruction
427 = (pvm_meta_instructions
428 + pvm_meta_instruction_id_unreachable);
429
430 /* Threads or pointers to native code blocks of course don't exist with
431 switch-dispatching. */
432 #ifndef JITTER_DISPATCH_SWITCH
433 the_pvm_vm.threads = (jitter_thread *)pvm_threads;
434 the_pvm_vm.thread_sizes = (long *) pvm_thread_sizes;
435 the_pvm_vm.threads_validated = pvm_threads_validated;
436 #if defined (JITTER_HAVE_KNOWN_BINARY_FORMAT)
437 the_pvm_vm.data_locations = JITTER_DATA_LOCATION_NAME(pvm);
438 #else
439 the_pvm_vm.data_locations = NULL;
440 #endif // #if defined (JITTER_HAVE_KNOWN_BINARY_FORMAT)
441 #endif // #ifndef JITTER_DISPATCH_SWITCH
442
443 the_pvm_vm.specialized_instruction_residual_arities
444 = pvm_specialized_instruction_residual_arities;
445 the_pvm_vm.specialized_instruction_label_bitmasks
446 = pvm_specialized_instruction_label_bitmasks;
447 #ifdef JITTER_HAVE_PATCH_IN
448 the_pvm_vm.specialized_instruction_fast_label_bitmasks
449 = pvm_specialized_instruction_fast_label_bitmasks;
450 the_pvm_vm.patch_in_descriptors =
451 JITTER_PATCH_IN_DESCRIPTORS_NAME(pvm);
452 const size_t patch_in_descriptor_size
453 = sizeof (struct jitter_patch_in_descriptor);
454 the_pvm_vm.patch_in_descriptor_no
455 = (JITTER_PATCH_IN_DESCRIPTORS_SIZE_IN_BYTES_NAME(pvm)
456 / patch_in_descriptor_size);
457 /* Cheap sanity check: if the size in bytes is not a multiple of
458 the element size, we're doing something very wrong. */
459 if (JITTER_PATCH_IN_DESCRIPTORS_SIZE_IN_BYTES_NAME(pvm)
460 % patch_in_descriptor_size != 0)
461 jitter_fatal ("patch-in descriptors total size not a multiple "
462 "of the element size");
463 /* Initialize the patch-in table for this VM. */
464 the_pvm_vm.patch_in_table
465 = jitter_make_patch_in_table (the_pvm_vm.patch_in_descriptors,
466 the_pvm_vm.patch_in_descriptor_no,
467 PVM_SPECIALIZED_INSTRUCTION_NO);
468 #else
469 the_pvm_vm.specialized_instruction_fast_label_bitmasks = NULL;
470 #endif // #ifdef JITTER_HAVE_PATCH_IN
471
472 /* FIXME: I might want to conditionalize this. */
473 the_pvm_vm.specialized_instruction_relocatables
474 = pvm_specialized_instruction_relocatables;
475
476 the_pvm_vm.specialized_instruction_callers
477 = pvm_specialized_instruction_callers;
478 the_pvm_vm.specialized_instruction_callees
479 = pvm_specialized_instruction_callees;
480
481 the_pvm_vm.specialized_instruction_names
482 = pvm_specialized_instruction_names;
483 the_pvm_vm.specialized_instruction_no
484 = PVM_SPECIALIZED_INSTRUCTION_NO;
485
486 the_pvm_vm.meta_instruction_string_hash
487 = & pvm_meta_instruction_hash;
488 the_pvm_vm.meta_instructions
489 = (struct jitter_meta_instruction *) pvm_meta_instructions;
490 the_pvm_vm.meta_instruction_no = PVM_META_INSTRUCTION_NO;
491 the_pvm_vm.max_meta_instruction_name_length
492 = PVM_MAX_META_INSTRUCTION_NAME_LENGTH;
493 the_pvm_vm.specialized_instruction_to_unspecialized_instruction
494 = pvm_specialized_instruction_to_unspecialized_instruction;
495 the_pvm_vm.register_class_character_to_register_class
496 = pvm_register_class_character_to_register_class;
497 the_pvm_vm.specialize_instruction = pvm_specialize_instruction;
498 the_pvm_vm.rewrite = pvm_rewrite;
499
500 #ifdef JITTER_HAVE_PATCH_IN
501 /* Fill the defect table. Since the array in question is a global with a
502 fixed size, this needs to be done only once. */
503 jitter_fill_defect_table (pvm_defect_table,
504 & the_pvm_vm,
505 pvm_worst_case_defect_table,
506 JITTER_DEFECT_DESCRIPTORS_NAME (pvm),
507 (JITTER_DEFECT_DESCRIPTORS_SIZE_IN_BYTES_NAME
508 (pvm)
509 / sizeof (struct jitter_defect_descriptor)));
510 #endif // #ifdef JITTER_HAVE_PATCH_IN
511
512 /* Initialize the empty list of states. */
513 JITTER_LIST_INITIALIZE_HEADER (& the_pvm_vm.states);
514
515 vm_struct_initialized = true;
516 }
517
518 jitter_initialize_meta_instructions (& pvm_meta_instruction_hash,
519 pvm_meta_instructions,
520 PVM_META_INSTRUCTION_NO);
521
522 #ifdef JITTER_HAVE_PATCH_IN
523 jitter_dump_defect_table (stderr, pvm_defect_table, & the_pvm_vm);
524 #endif // #ifdef JITTER_HAVE_PATCH_IN
525 }
526
527 void
pvm_finalize(void)528 pvm_finalize (void)
529 {
530 /* There's no need to touch the_pvm_vm ; we can keep it as it is, as it
531 contains no dynamically-allocated fields. */
532 /* Threads need no finalization. */
533 jitter_finalize_meta_instructions (& pvm_meta_instruction_hash);
534
535 #ifdef JITTER_HAVE_PATCH_IN
536 /* Destroy the patch-in table for this VM. */
537 jitter_destroy_patch_in_table (the_pvm_vm.patch_in_table,
538 PVM_SPECIALIZED_INSTRUCTION_NO);
539 #endif // #ifdef JITTER_HAVE_PATCH_IN
540
541 #ifdef JITTER_REPLICATE
542 /* Finalize the executable-memory subsystem. */
543 jitter_finalize_executable ();
544 #endif // #ifdef JITTER_REPLICATE
545
546 /* Finalize the state list. If it is not empty then something has gone
547 wrong earlier. */
548 if (the_pvm_vm.states.first != NULL
549 || the_pvm_vm.states.last != NULL)
550 jitter_fatal ("not every state structure was destroyed before PVM "
551 "finalisation.");
552 }
553
554
555
556
557 /* VM-dependant mutable routine initialization.
558 * ************************************************************************** */
559
560 struct jitter_mutable_routine*
pvm_make_mutable_routine(void)561 pvm_make_mutable_routine (void)
562 {
563 return jitter_make_mutable_routine (pvm_vm);
564 }
565
566
567
568
569 /* Sample profiling: internal API.
570 * ************************************************************************** */
571
572 #if defined (JITTER_PROFILE_SAMPLE)
573
574 /* Sample profiling depends on some system features: fail immediately if they
575 are not available */
576 #if ! defined (JITTER_HAVE_SIGACTION) || ! defined (JITTER_HAVE_SETITIMER)
577 # jitter_fatal "sample-profiling depends on sigaction and setitimer"
578 #endif
579
580 static struct itimerval
581 pvm_timer_interval;
582
583 static struct itimerval
584 pvm_timer_disabled_interval;
585
586 /* The sampling data, currently global. The current implementation does not
587 play well with threads, but it can be changed later keeping the same user
588 API. */
589 struct pvm_sample_profile_state
590 {
591 /* The state currently sample-profiling. Since such a state can be only one
592 right now this field is useful for printing error messages in case the user
593 sets up sample-profiling from two states at the same time by mistake.
594 This field is also useful for temporarily suspending and then reenabling
595 sampling, when The Array is being resized: if the signal handler sees that
596 this field is NULL it will not touch the fields. */
597 struct pvm_state *state_p;
598
599 /* A pointer to the counts field within the sample_profile_runtime struct. */
600 uint32_t *counts;
601
602 /* A pointer to the current specialised instruction opcode within the
603 sample_profile_runtime struct. */
604 volatile jitter_int * specialized_opcode_p;
605
606 /* A pointer to the field counting the number of samples, again within the
607 sample_profile_runtime struct. */
608 unsigned int *sample_no_p;
609 };
610
611 /* The (currently) one and only global state for sample-profiling. */
612 static struct pvm_sample_profile_state
613 pvm_sample_profile_state;
614
615 static void
pvm_sigprof_handler(int signal)616 pvm_sigprof_handler (int signal)
617 {
618 #if 0
619 assert (pvm_sample_profile_state.state_p != NULL);
620 #endif
621
622 jitter_int specialized_opcode
623 = * pvm_sample_profile_state.specialized_opcode_p;
624 if (__builtin_expect ((specialized_opcode >= 0
625 && (specialized_opcode
626 < PVM_SPECIALIZED_INSTRUCTION_NO)),
627 true))
628 pvm_sample_profile_state.counts [specialized_opcode] ++;
629
630 (* pvm_sample_profile_state.sample_no_p) ++;
631 }
632
633 void
pvm_profile_sample_initialize(void)634 pvm_profile_sample_initialize (void)
635 {
636 /* Perform a sanity check over the sampling period. */
637 if (JITTER_PROFILE_SAMPLE_PERIOD_IN_MILLISECONDS <= 0 ||
638 JITTER_PROFILE_SAMPLE_PERIOD_IN_MILLISECONDS >= 1000)
639 jitter_fatal ("invalid JITTER_PROFILE_SAMPLE_PERIOD_IN_MILLISECONDS: %f",
640 (double) JITTER_PROFILE_SAMPLE_PERIOD_IN_MILLISECONDS);
641 struct sigaction action;
642 sigaction (SIGPROF, NULL, & action);
643 action.sa_handler = pvm_sigprof_handler;
644 sigaction (SIGPROF, & action, NULL);
645
646 long microseconds
647 = (long) (JITTER_PROFILE_SAMPLE_PERIOD_IN_MILLISECONDS * 1000);
648 pvm_timer_interval.it_interval.tv_sec = 0;
649 pvm_timer_interval.it_interval.tv_usec = microseconds;
650 pvm_timer_interval.it_value = pvm_timer_interval.it_interval;
651
652 pvm_sample_profile_state.state_p = NULL;
653 pvm_timer_disabled_interval.it_interval.tv_sec = 0;
654 pvm_timer_disabled_interval.it_interval.tv_usec = 0;
655 pvm_timer_disabled_interval.it_value
656 = pvm_timer_disabled_interval.it_interval;
657 }
658
659 void
pvm_profile_sample_start(struct pvm_state * state_p)660 pvm_profile_sample_start (struct pvm_state *state_p)
661 {
662 struct jitter_sample_profile_runtime *spr
663 = ((struct jitter_sample_profile_runtime *)
664 & PVM_STATE_TO_SPECIAL_PURPOSE_STATE_DATA (state_p)
665 ->profile_runtime.sample_profile_runtime);
666
667 if (pvm_sample_profile_state.state_p != NULL)
668 {
669 if (state_p != pvm_sample_profile_state.state_p)
670 jitter_fatal ("currently it is only possible to sample-profile from "
671 "one state at the time: trying to sample-profile from "
672 "the state %p when already sample-profiling from the "
673 "state %p",
674 state_p, pvm_sample_profile_state.state_p);
675 else
676 {
677 /* This situation is a symptom of a bug, but does not need to lead
678 to a fatal error. */
679 printf ("WARNING: starting profile on the state %p when profiling "
680 "was already active in the same state.\n"
681 "Did you call longjmp from VM code?", state_p);
682 fflush (stdout);
683 }
684 }
685 pvm_sample_profile_state.state_p = state_p;
686 pvm_sample_profile_state.sample_no_p = & spr->sample_no;
687 pvm_sample_profile_state.counts = spr->counts;
688 pvm_sample_profile_state.specialized_opcode_p
689 = & spr->current_specialized_instruction_opcode;
690 //fprintf (stderr, "SAMPLE START\n"); fflush (NULL);
691 if (setitimer (ITIMER_PROF, & pvm_timer_interval, NULL) != 0)
692 jitter_fatal ("setitimer failed when establishing a timer");
693 }
694
695 void
pvm_profile_sample_stop(void)696 pvm_profile_sample_stop (void)
697 {
698 if (setitimer (ITIMER_PROF, & pvm_timer_disabled_interval, NULL) != 0)
699 jitter_fatal ("setitimer failed when disabling a timer");
700
701 pvm_sample_profile_state.state_p = NULL;
702
703 /* The rest is just for defenisveness' sake. */
704 * pvm_sample_profile_state.specialized_opcode_p = -1;
705 pvm_sample_profile_state.sample_no_p = NULL;
706 pvm_sample_profile_state.counts = NULL;
707 pvm_sample_profile_state.specialized_opcode_p = NULL;
708 }
709 #endif // #if defined (JITTER_PROFILE_SAMPLE)
710
711
712
713
714 /* Array re-allocation.
715 * ************************************************************************** */
716
717 char *
pvm_make_place_for_slow_registers(struct pvm_state * s,jitter_int new_slow_register_no_per_class)718 pvm_make_place_for_slow_registers (struct pvm_state *s,
719 jitter_int new_slow_register_no_per_class)
720 {
721 if (new_slow_register_no_per_class < 0)
722 jitter_fatal ("pvm_make_place_for_slow_registers: negative slow "
723 "register number");
724 jitter_int old_slow_register_no_per_class
725 = s->pvm_state_backing.jitter_slow_register_no_per_class;
726 /* Change nothing if we already have enough space for the required number of
727 slow registers. The no-change case will be the most common one, and
728 this function might be worth optimizing. */
729 if (__builtin_expect (new_slow_register_no_per_class
730 > old_slow_register_no_per_class,
731 false))
732 {
733 #if defined (JITTER_PROFILE_SAMPLE)
734 /* If sample-profiling is currently in progress on this state suspend it
735 temporarily. */
736 bool suspending_sample_profiling
737 = (pvm_sample_profile_state.state_p == s);
738 if (suspending_sample_profiling)
739 pvm_profile_sample_stop ();
740 #endif // #if defined (JITTER_PROFILE_SAMPLE)
741
742 #if 0
743 printf ("Increasing slow register-no (per class) from %li to %li\n", (long) old_slow_register_no_per_class, (long)new_slow_register_no_per_class);
744 printf ("Array size %li -> %li\n", (long) PVM_ARRAY_SIZE(old_slow_register_no_per_class), (long) PVM_ARRAY_SIZE(new_slow_register_no_per_class));
745 #endif
746 /* Save the new value for new_slow_register_no_per_class in the state
747 structure; reallocate the Array. */
748 s->pvm_state_backing.jitter_slow_register_no_per_class
749 = new_slow_register_no_per_class;
750 s->pvm_state_backing.jitter_array
751 = jitter_xrealloc ((void *) s->pvm_state_backing.jitter_array,
752 PVM_ARRAY_SIZE(new_slow_register_no_per_class));
753
754 /* Initialise the slow registers we have just added, for every class. */
755 union pvm_any_register *first_slow_register
756 = ((union pvm_any_register *)
757 ((char *) s->pvm_state_backing.jitter_array
758 + PVM_FIRST_SLOW_REGISTER_UNBIASED_OFFSET));
759 jitter_int i;
760 for (i = old_slow_register_no_per_class;
761 i < new_slow_register_no_per_class;
762 i ++)
763 {
764 /* A pointer to the i-th rank of slow registers. Every register
765 in the rank is new and in general (according to its class) may
766 need initialisation. */
767 union pvm_any_register *rank
768 = first_slow_register + (i * PVM_REGISTER_CLASS_NO);
769 PVM_INITIALIZE_SLOW_REGISTER_RANK (rank);
770 }
771 #if defined (JITTER_PROFILE_SAMPLE)
772 /* Now we can resume sample-profiling on this state if we suspended it. */
773 if (suspending_sample_profiling)
774 pvm_profile_sample_start (s);
775 #endif // #if defined (JITTER_PROFILE_SAMPLE)
776 #if 0
777 printf ("Done resizing The Array\n");
778 #endif
779 }
780
781 /* Return the new (or unchanged) base, by simply adding the bias to the
782 Array as it is now. */
783 return s->pvm_state_backing.jitter_array + JITTER_ARRAY_BIAS;
784 }
785
786 void
pvm_ensure_enough_slow_registers_for_executable_routine(const struct jitter_executable_routine * er,struct pvm_state * s)787 pvm_ensure_enough_slow_registers_for_executable_routine
788 (const struct jitter_executable_routine *er, struct pvm_state *s)
789 {
790 pvm_make_place_for_slow_registers (s, er->slow_register_per_class_no);
791 }
792
793
794
795
796 /* Program text frontend.
797 * ************************************************************************** */
798
799 void
pvm_parse_mutable_routine_from_file_star(FILE * input_file,struct jitter_mutable_routine * p)800 pvm_parse_mutable_routine_from_file_star (FILE *input_file,
801 struct jitter_mutable_routine *p)
802 {
803 jitter_parse_mutable_routine_from_file_star (input_file, p, pvm_vm);
804 }
805
806 void
pvm_parse_mutable_routine_from_file(const char * input_file_name,struct jitter_mutable_routine * p)807 pvm_parse_mutable_routine_from_file (const char *input_file_name,
808 struct jitter_mutable_routine *p)
809 {
810 jitter_parse_mutable_routine_from_file (input_file_name, p, pvm_vm);
811 }
812
813 void
pvm_parse_mutable_routine_from_string(const char * string,struct jitter_mutable_routine * p)814 pvm_parse_mutable_routine_from_string (const char *string,
815 struct jitter_mutable_routine *p)
816 {
817 jitter_parse_mutable_routine_from_string (string, p, pvm_vm);
818 }
819
820
821
822
823 /* Executing code: unified routine API.
824 * ************************************************************************** */
825
826 void
pvm_ensure_enough_slow_registers_for_routine(jitter_routine r,struct pvm_state * s)827 pvm_ensure_enough_slow_registers_for_routine
828 (jitter_routine r, struct pvm_state *s)
829 {
830 struct jitter_executable_routine *e
831 = jitter_routine_make_executable_if_needed (r);
832 pvm_ensure_enough_slow_registers_for_executable_routine (e, s);
833 }
834
835 void
pvm_execute_routine(jitter_routine r,struct pvm_state * s)836 pvm_execute_routine (jitter_routine r,
837 struct pvm_state *s)
838 {
839 struct jitter_executable_routine *e
840 = jitter_routine_make_executable_if_needed (r);
841 pvm_execute_executable_routine (e, s);
842 }
843
844
845
846
847 /* Profiling: user API.
848 * ************************************************************************** */
849
850 /* These functions are all trivial wrappers around the functionality declared
851 in jitter/jitter-profile.h, hiding the VM pointer. */
852
853 struct pvm_profile_runtime *
pvm_state_profile_runtime(struct pvm_state * s)854 pvm_state_profile_runtime (struct pvm_state *s)
855 {
856 volatile struct jitter_special_purpose_state_data *spd
857 = PVM_ARRAY_TO_SPECIAL_PURPOSE_STATE_DATA
858 (s->pvm_state_backing.jitter_array);
859 return (struct pvm_profile_runtime *) & spd->profile_runtime;
860 }
861
862 struct pvm_profile_runtime *
pvm_profile_runtime_make(void)863 pvm_profile_runtime_make (void)
864 {
865 return jitter_profile_runtime_make (pvm_vm);
866 }
867
868 void
pvm_profile_runtime_clear(struct pvm_profile_runtime * p)869 pvm_profile_runtime_clear (struct pvm_profile_runtime * p)
870 {
871 jitter_profile_runtime_clear (pvm_vm, p);
872 }
873
874 void
pvm_profile_runtime_merge_from(struct pvm_profile_runtime * to,const struct pvm_profile_runtime * from)875 pvm_profile_runtime_merge_from (struct pvm_profile_runtime *to,
876 const struct pvm_profile_runtime *from)
877 {
878 jitter_profile_runtime_merge_from (pvm_vm, to, from);
879 }
880
881 void
pvm_profile_runtime_merge_from_state(struct pvm_profile_runtime * to,const struct pvm_state * from_state)882 pvm_profile_runtime_merge_from_state (struct pvm_profile_runtime *to,
883 const struct pvm_state *from_state)
884 {
885 const struct pvm_profile_runtime* from
886 = pvm_state_profile_runtime ((struct pvm_state *) from_state);
887 jitter_profile_runtime_merge_from (pvm_vm, to, from);
888 }
889
890 void
pvm_profile_runtime_print_unspecialized(jitter_print_context ct,const struct pvm_profile_runtime * p)891 pvm_profile_runtime_print_unspecialized
892 (jitter_print_context ct,
893 const struct pvm_profile_runtime *p)
894 {
895 jitter_profile_runtime_print_unspecialized (ct, pvm_vm, p);
896 }
897
898 void
pvm_profile_runtime_print_specialized(jitter_print_context ct,const struct pvm_profile_runtime * p)899 pvm_profile_runtime_print_specialized (jitter_print_context ct,
900 const struct pvm_profile_runtime
901 *p)
902 {
903 jitter_profile_runtime_print_specialized (ct, pvm_vm, p);
904 }
905
906 struct pvm_profile *
pvm_profile_unspecialized_from_runtime(const struct pvm_profile_runtime * p)907 pvm_profile_unspecialized_from_runtime
908 (const struct pvm_profile_runtime *p)
909 {
910 return jitter_profile_unspecialized_from_runtime (pvm_vm, p);
911 }
912
913 struct pvm_profile *
pvm_profile_specialized_from_runtime(const struct pvm_profile_runtime * p)914 pvm_profile_specialized_from_runtime (const struct pvm_profile_runtime
915 *p)
916 {
917 return jitter_profile_specialized_from_runtime (pvm_vm, p);
918 }
919
920
921
922
923 /* Evrything following this point is machine-generated.
924 * ************************************************************************** */
925
926 /* What follows could be conceptually split into several generated C files, but
927 having too many of them would be inconvenient for the user to compile and
928 link. For this reason we currently generate just three files: one is this,
929 which also contains the specializer, another is for the executor, and then a
930 header -- a main module is optional. The executor will be potentially very
931 large, so it is best compiled separately. The specializer might be large as
932 well at this stage, even if its compilation is usually much less
933 expensive. */
934 /* These two macros are convenient for making VM-specific identifiers
935 using VM-independent macros from a public header, without polluting
936 the global namespace. */
937 #define JITTER_VM_PREFIX_LOWER_CASE pvm
938 #define JITTER_VM_PREFIX_UPPER_CASE PVM
939
940 /* User-specified code, printer part: beginning. */
941 #line 707 "../../libpoke/pvm.jitter"
942 #line 707 "../../libpoke/pvm.jitter"
943
944 static jitter_uint printer_hi;
945
946 static void
pvm_literal_printer_cast(jitter_print_context out,jitter_uint val)947 pvm_literal_printer_cast (jitter_print_context out, jitter_uint val)
948 {
949 pk_printf ("%" JITTER_PRIu, val);
950 pk_term_flush ();
951 }
952
953 static void
pvm_literal_printer(jitter_print_context out,jitter_uint val)954 pvm_literal_printer (jitter_print_context out, jitter_uint val)
955 {
956 pvm_print_val_with_params (NULL /* not used since no
957 pretty-print */,
958 (pvm_val) val,
959 1 /* depth */,
960 PVM_PRINT_FLAT,
961 16 /* base */,
962 0 /* indent */,
963 2 /* acutoff */,
964 0 /* flags */);
965 pk_term_flush ();
966 }
967
968 static void
pvm_literal_printer_hi(jitter_print_context out,jitter_uint hi)969 pvm_literal_printer_hi (jitter_print_context out, jitter_uint hi)
970 {
971 pk_printf ("%%hi(0x%" JITTER_PRIx ")", hi);
972 pk_term_flush ();
973 printer_hi = hi; /* This sucks */
974 }
975
976 static void
pvm_literal_printer_lo(jitter_print_context out,jitter_uint lo)977 pvm_literal_printer_lo (jitter_print_context out, jitter_uint lo)
978 {
979 pk_printf ("%%lo(0x%" JITTER_PRIx") (", lo);
980
981 pvm_print_val_with_params (NULL /* not used since no
982 pretty-print */,
983 ((pvm_val) printer_hi << 32) | lo,
984 1 /* depth */,
985 PVM_PRINT_FLAT,
986 16 /* base */,
987 0 /* indent */,
988 2 /* acutoff */,
989 0 /* flags */);
990 pk_puts (")");
991 pk_term_flush ();
992 printer_hi = 0;
993 }
994
995 static void
popf_printer(jitter_print_context out,jitter_uint nframes)996 popf_printer (jitter_print_context out, jitter_uint nframes)
997 {
998 pk_printf ("%" JITTER_PRIu, nframes);
999 pk_term_flush ();
1000 }
1001
1002 static void
bits_printer(jitter_print_context out,jitter_uint val)1003 bits_printer (jitter_print_context out, jitter_uint val)
1004 {
1005 pk_printf ("%" JITTER_PRIu, val);
1006 pk_term_flush ();
1007 }
1008
1009 static void
endian_printer(jitter_print_context out,jitter_uint val)1010 endian_printer (jitter_print_context out, jitter_uint val)
1011 {
1012 pk_printf ("%s", val == IOS_ENDIAN_MSB ? "big" : "little");
1013 pk_term_flush ();
1014 }
1015
1016 static void
nenc_printer(jitter_print_context out,jitter_uint val)1017 nenc_printer (jitter_print_context out, jitter_uint val)
1018 {
1019 pk_printf ("%s", val == IOS_NENC_1 ? "1c" : "2c");
1020 pk_term_flush ();
1021 }
1022
1023 /* User-specified code, printer part: end */
1024
1025 //#include <stdbool.h>
1026
1027 //#include <jitter/jitter.h>
1028 //#include <jitter/jitter-instruction.h>
1029
1030 //#include "pvm-meta-instructions.h"
1031
1032 // FIXME: comment.
1033 struct jitter_hash_table
1034 pvm_meta_instruction_hash;
1035
1036
1037 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_ba_meta_instruction_parameter_types [1] =
1038 { { jitter_meta_instruction_parameter_kind_literal_label, NULL, jitter_default_literal_parameter_printer } };
1039
1040 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_bn_meta_instruction_parameter_types [1] =
1041 { { jitter_meta_instruction_parameter_kind_literal_label, NULL, jitter_default_literal_parameter_printer } };
1042
1043 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_bnn_meta_instruction_parameter_types [1] =
1044 { { jitter_meta_instruction_parameter_kind_literal_label, NULL, jitter_default_literal_parameter_printer } };
1045
1046 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_bnzi_meta_instruction_parameter_types [1] =
1047 { { jitter_meta_instruction_parameter_kind_literal_label, NULL, jitter_default_literal_parameter_printer } };
1048
1049 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_bnziu_meta_instruction_parameter_types [1] =
1050 { { jitter_meta_instruction_parameter_kind_literal_label, NULL, jitter_default_literal_parameter_printer } };
1051
1052 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_bnzl_meta_instruction_parameter_types [1] =
1053 { { jitter_meta_instruction_parameter_kind_literal_label, NULL, jitter_default_literal_parameter_printer } };
1054
1055 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_bnzlu_meta_instruction_parameter_types [1] =
1056 { { jitter_meta_instruction_parameter_kind_literal_label, NULL, jitter_default_literal_parameter_printer } };
1057
1058 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_bzi_meta_instruction_parameter_types [1] =
1059 { { jitter_meta_instruction_parameter_kind_literal_label, NULL, jitter_default_literal_parameter_printer } };
1060
1061 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_bziu_meta_instruction_parameter_types [1] =
1062 { { jitter_meta_instruction_parameter_kind_literal_label, NULL, jitter_default_literal_parameter_printer } };
1063
1064 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_bzl_meta_instruction_parameter_types [1] =
1065 { { jitter_meta_instruction_parameter_kind_literal_label, NULL, jitter_default_literal_parameter_printer } };
1066
1067 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_bzlu_meta_instruction_parameter_types [1] =
1068 { { jitter_meta_instruction_parameter_kind_literal_label, NULL, jitter_default_literal_parameter_printer } };
1069
1070 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_itoi_meta_instruction_parameter_types [1] =
1071 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, pvm_literal_printer_cast } };
1072
1073 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_itoiu_meta_instruction_parameter_types [1] =
1074 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, pvm_literal_printer_cast } };
1075
1076 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_itol_meta_instruction_parameter_types [1] =
1077 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, pvm_literal_printer_cast } };
1078
1079 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_itolu_meta_instruction_parameter_types [1] =
1080 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, pvm_literal_printer_cast } };
1081
1082 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_iutoi_meta_instruction_parameter_types [1] =
1083 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, pvm_literal_printer_cast } };
1084
1085 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_iutoiu_meta_instruction_parameter_types [1] =
1086 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, pvm_literal_printer_cast } };
1087
1088 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_iutol_meta_instruction_parameter_types [1] =
1089 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, pvm_literal_printer_cast } };
1090
1091 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_iutolu_meta_instruction_parameter_types [1] =
1092 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, pvm_literal_printer_cast } };
1093
1094 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_ltoi_meta_instruction_parameter_types [1] =
1095 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, pvm_literal_printer_cast } };
1096
1097 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_ltoiu_meta_instruction_parameter_types [1] =
1098 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, pvm_literal_printer_cast } };
1099
1100 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_ltol_meta_instruction_parameter_types [1] =
1101 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, pvm_literal_printer_cast } };
1102
1103 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_ltolu_meta_instruction_parameter_types [1] =
1104 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, pvm_literal_printer_cast } };
1105
1106 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_lutoi_meta_instruction_parameter_types [1] =
1107 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, pvm_literal_printer_cast } };
1108
1109 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_lutoiu_meta_instruction_parameter_types [1] =
1110 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, pvm_literal_printer_cast } };
1111
1112 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_lutol_meta_instruction_parameter_types [1] =
1113 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, pvm_literal_printer_cast } };
1114
1115 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_lutolu_meta_instruction_parameter_types [1] =
1116 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, pvm_literal_printer_cast } };
1117
1118 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_note_meta_instruction_parameter_types [1] =
1119 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, pvm_literal_printer } };
1120
1121 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_peekdi_meta_instruction_parameter_types [1] =
1122 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, bits_printer } };
1123
1124 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_peekdiu_meta_instruction_parameter_types [1] =
1125 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, bits_printer } };
1126
1127 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_peekdl_meta_instruction_parameter_types [1] =
1128 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, bits_printer } };
1129
1130 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_peekdlu_meta_instruction_parameter_types [1] =
1131 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, bits_printer } };
1132
1133 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_peeki_meta_instruction_parameter_types [3] =
1134 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, nenc_printer }, { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, endian_printer }, { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, bits_printer } };
1135
1136 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_peekiu_meta_instruction_parameter_types [2] =
1137 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, endian_printer }, { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, bits_printer } };
1138
1139 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_peekl_meta_instruction_parameter_types [3] =
1140 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, nenc_printer }, { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, endian_printer }, { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, bits_printer } };
1141
1142 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_peeklu_meta_instruction_parameter_types [2] =
1143 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, endian_printer }, { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, bits_printer } };
1144
1145 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_pokedi_meta_instruction_parameter_types [1] =
1146 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, bits_printer } };
1147
1148 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_pokediu_meta_instruction_parameter_types [1] =
1149 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, bits_printer } };
1150
1151 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_pokedl_meta_instruction_parameter_types [1] =
1152 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, bits_printer } };
1153
1154 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_pokedlu_meta_instruction_parameter_types [1] =
1155 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, bits_printer } };
1156
1157 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_pokei_meta_instruction_parameter_types [3] =
1158 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, nenc_printer }, { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, endian_printer }, { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, bits_printer } };
1159
1160 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_pokeiu_meta_instruction_parameter_types [2] =
1161 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, endian_printer }, { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, bits_printer } };
1162
1163 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_pokel_meta_instruction_parameter_types [3] =
1164 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, nenc_printer }, { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, endian_printer }, { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, bits_printer } };
1165
1166 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_pokelu_meta_instruction_parameter_types [2] =
1167 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, endian_printer }, { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, bits_printer } };
1168
1169 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_popf_meta_instruction_parameter_types [1] =
1170 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, popf_printer } };
1171
1172 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_popr_meta_instruction_parameter_types [1] =
1173 { { jitter_meta_instruction_parameter_kind_register, & pvm_register_class_r, jitter_default_literal_parameter_printer } };
1174
1175 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_popvar_meta_instruction_parameter_types [2] =
1176 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, jitter_default_literal_parameter_printer }, { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, jitter_default_literal_parameter_printer } };
1177
1178 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_printi_meta_instruction_parameter_types [1] =
1179 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, popf_printer } };
1180
1181 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_printiu_meta_instruction_parameter_types [1] =
1182 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, popf_printer } };
1183
1184 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_printl_meta_instruction_parameter_types [1] =
1185 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, popf_printer } };
1186
1187 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_printlu_meta_instruction_parameter_types [1] =
1188 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, popf_printer } };
1189
1190 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_push_meta_instruction_parameter_types [1] =
1191 { { jitter_meta_instruction_parameter_kind_literal_fixnum_or_literal_label, NULL, pvm_literal_printer } };
1192
1193 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_push32_meta_instruction_parameter_types [1] =
1194 { { jitter_meta_instruction_parameter_kind_literal_fixnum_or_literal_label, NULL, pvm_literal_printer } };
1195
1196 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_pushe_meta_instruction_parameter_types [1] =
1197 { { jitter_meta_instruction_parameter_kind_literal_label, NULL, jitter_default_literal_parameter_printer } };
1198
1199 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_pushf_meta_instruction_parameter_types [1] =
1200 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, popf_printer } };
1201
1202 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_pushhi_meta_instruction_parameter_types [1] =
1203 { { jitter_meta_instruction_parameter_kind_literal_fixnum_or_literal_label, NULL, pvm_literal_printer_hi } };
1204
1205 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_pushlo_meta_instruction_parameter_types [1] =
1206 { { jitter_meta_instruction_parameter_kind_literal_fixnum_or_literal_label, NULL, pvm_literal_printer_lo } };
1207
1208 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_pushr_meta_instruction_parameter_types [1] =
1209 { { jitter_meta_instruction_parameter_kind_register, & pvm_register_class_r, jitter_default_literal_parameter_printer } };
1210
1211 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_pushtopvar_meta_instruction_parameter_types [1] =
1212 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, jitter_default_literal_parameter_printer } };
1213
1214 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_pushvar_meta_instruction_parameter_types [2] =
1215 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, jitter_default_literal_parameter_printer }, { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, jitter_default_literal_parameter_printer } };
1216
1217 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_restorer_meta_instruction_parameter_types [1] =
1218 { { jitter_meta_instruction_parameter_kind_register, & pvm_register_class_r, jitter_default_literal_parameter_printer } };
1219
1220 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_revn_meta_instruction_parameter_types [1] =
1221 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, popf_printer } };
1222
1223 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_saver_meta_instruction_parameter_types [1] =
1224 { { jitter_meta_instruction_parameter_kind_register, & pvm_register_class_r, jitter_default_literal_parameter_printer } };
1225
1226 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_setr_meta_instruction_parameter_types [1] =
1227 { { jitter_meta_instruction_parameter_kind_register, & pvm_register_class_r, jitter_default_literal_parameter_printer } };
1228
1229 static const /*FIXME: use enum jitterc_instruction_argument_kind instead*/struct jitter_meta_instruction_parameter_type pvm_strace_meta_instruction_parameter_types [1] =
1230 { { jitter_meta_instruction_parameter_kind_literal_fixnum, NULL, jitter_default_literal_parameter_printer } };
1231
1232
1233 const struct jitter_meta_instruction
1234 pvm_meta_instructions [PVM_META_INSTRUCTION_NO]
1235 = {
1236 { 0, "addi", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1237 { 1, "addiu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1238 { 2, "addl", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1239 { 3, "addlu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1240 { 4, "ains", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1241 { 5, "and", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1242 { 6, "aref", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1243 { 7, "arefo", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1244 { 8, "arem", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1245 { 9, "aset", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1246 { 10, "asettb", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1247 { 11, "atr", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1248 { 12, "ba", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_ba_meta_instruction_parameter_types },
1249 { 13, "bandi", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1250 { 14, "bandiu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1251 { 15, "bandl", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1252 { 16, "bandlu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1253 { 17, "beghl", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1254 { 18, "begsc", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1255 { 19, "bn", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_bn_meta_instruction_parameter_types },
1256 { 20, "bnn", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_bnn_meta_instruction_parameter_types },
1257 { 21, "bnoti", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1258 { 22, "bnotiu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1259 { 23, "bnotl", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1260 { 24, "bnotlu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1261 { 25, "bnzi", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_bnzi_meta_instruction_parameter_types },
1262 { 26, "bnziu", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_bnziu_meta_instruction_parameter_types },
1263 { 27, "bnzl", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_bnzl_meta_instruction_parameter_types },
1264 { 28, "bnzlu", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_bnzlu_meta_instruction_parameter_types },
1265 { 29, "bori", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1266 { 30, "boriu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1267 { 31, "borl", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1268 { 32, "borlu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1269 { 33, "bsli", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1270 { 34, "bsliu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1271 { 35, "bsll", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1272 { 36, "bsllu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1273 { 37, "bsri", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1274 { 38, "bsriu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1275 { 39, "bsrl", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1276 { 40, "bsrlu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1277 { 41, "bxori", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1278 { 42, "bxoriu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1279 { 43, "bxorl", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1280 { 44, "bxorlu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1281 { 45, "bzi", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_bzi_meta_instruction_parameter_types },
1282 { 46, "bziu", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_bziu_meta_instruction_parameter_types },
1283 { 47, "bzl", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_bzl_meta_instruction_parameter_types },
1284 { 48, "bzlu", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_bzlu_meta_instruction_parameter_types },
1285 { 49, "call", 0, true, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1286 { 50, "canary", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1287 { 51, "close", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1288 { 52, "ctos", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1289 { 53, "disas", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1290 { 54, "divi", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1291 { 55, "diviu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1292 { 56, "divl", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1293 { 57, "divlu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1294 { 58, "drop", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1295 { 59, "drop2", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1296 { 60, "drop3", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1297 { 61, "drop4", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1298 { 62, "duc", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1299 { 63, "dup", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1300 { 64, "endhl", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1301 { 65, "endsc", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1302 { 66, "eqi", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1303 { 67, "eqiu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1304 { 68, "eql", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1305 { 69, "eqlu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1306 { 70, "eqs", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1307 { 71, "exit", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1308 { 72, "exitvm", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1309 { 73, "flush", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1310 { 74, "fromr", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1311 { 75, "gei", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1312 { 76, "geiu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1313 { 77, "gel", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1314 { 78, "gelu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1315 { 79, "ges", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1316 { 80, "getenv", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1317 { 81, "gti", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1318 { 82, "gtiu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1319 { 83, "gtl", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1320 { 84, "gtlu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1321 { 85, "gts", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1322 { 86, "indent", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1323 { 87, "iogetb", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1324 { 88, "iosetb", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1325 { 89, "iosize", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1326 { 90, "isa", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1327 { 91, "itoi", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_itoi_meta_instruction_parameter_types },
1328 { 92, "itoiu", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_itoiu_meta_instruction_parameter_types },
1329 { 93, "itol", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_itol_meta_instruction_parameter_types },
1330 { 94, "itolu", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_itolu_meta_instruction_parameter_types },
1331 { 95, "iutoi", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_iutoi_meta_instruction_parameter_types },
1332 { 96, "iutoiu", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_iutoiu_meta_instruction_parameter_types },
1333 { 97, "iutol", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_iutol_meta_instruction_parameter_types },
1334 { 98, "iutolu", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_iutolu_meta_instruction_parameter_types },
1335 { 99, "lei", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1336 { 100, "leiu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1337 { 101, "lel", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1338 { 102, "lelu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1339 { 103, "les", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1340 { 104, "lti", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1341 { 105, "ltiu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1342 { 106, "ltl", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1343 { 107, "ltlu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1344 { 108, "ltoi", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_ltoi_meta_instruction_parameter_types },
1345 { 109, "ltoiu", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_ltoiu_meta_instruction_parameter_types },
1346 { 110, "ltol", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_ltol_meta_instruction_parameter_types },
1347 { 111, "ltolu", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_ltolu_meta_instruction_parameter_types },
1348 { 112, "lts", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1349 { 113, "lutoi", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_lutoi_meta_instruction_parameter_types },
1350 { 114, "lutoiu", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_lutoiu_meta_instruction_parameter_types },
1351 { 115, "lutol", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_lutol_meta_instruction_parameter_types },
1352 { 116, "lutolu", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_lutolu_meta_instruction_parameter_types },
1353 { 117, "map", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1354 { 118, "mgetios", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1355 { 119, "mgetm", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1356 { 120, "mgeto", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1357 { 121, "mgets", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1358 { 122, "mgetsel", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1359 { 123, "mgetsiz", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1360 { 124, "mgetw", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1361 { 125, "mka", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1362 { 126, "mko", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1363 { 127, "mksct", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1364 { 128, "mktya", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1365 { 129, "mktyany", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1366 { 130, "mktyc", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1367 { 131, "mktyi", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1368 { 132, "mktyo", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1369 { 133, "mktys", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1370 { 134, "mktysct", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1371 { 135, "mktyv", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1372 { 136, "mm", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1373 { 137, "modi", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1374 { 138, "modiu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1375 { 139, "modl", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1376 { 140, "modlu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1377 { 141, "msetios", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1378 { 142, "msetm", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1379 { 143, "mseto", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1380 { 144, "msets", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1381 { 145, "msetsel", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1382 { 146, "msetsiz", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1383 { 147, "msetw", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1384 { 148, "muli", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1385 { 149, "muliu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1386 { 150, "mull", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1387 { 151, "mullu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1388 { 152, "muls", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1389 { 153, "negi", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1390 { 154, "negiu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1391 { 155, "negl", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1392 { 156, "neglu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1393 { 157, "nei", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1394 { 158, "neiu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1395 { 159, "nel", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1396 { 160, "nelu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1397 { 161, "nes", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1398 { 162, "nip", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1399 { 163, "nip2", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1400 { 164, "nip3", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1401 { 165, "nn", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1402 { 166, "nnn", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1403 { 167, "nop", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1404 { 168, "not", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1405 { 169, "note", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_note_meta_instruction_parameter_types },
1406 { 170, "nrot", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1407 { 171, "ogetbt", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1408 { 172, "ogetm", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1409 { 173, "ogetu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1410 { 174, "open", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1411 { 175, "or", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1412 { 176, "osetm", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1413 { 177, "over", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1414 { 178, "pec", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1415 { 179, "peekdi", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_peekdi_meta_instruction_parameter_types },
1416 { 180, "peekdiu", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_peekdiu_meta_instruction_parameter_types },
1417 { 181, "peekdl", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_peekdl_meta_instruction_parameter_types },
1418 { 182, "peekdlu", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_peekdlu_meta_instruction_parameter_types },
1419 { 183, "peeki", 3, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_peeki_meta_instruction_parameter_types },
1420 { 184, "peekiu", 2, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_peekiu_meta_instruction_parameter_types },
1421 { 185, "peekl", 3, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_peekl_meta_instruction_parameter_types },
1422 { 186, "peeklu", 2, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_peeklu_meta_instruction_parameter_types },
1423 { 187, "peeks", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1424 { 188, "pokedi", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_pokedi_meta_instruction_parameter_types },
1425 { 189, "pokediu", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_pokediu_meta_instruction_parameter_types },
1426 { 190, "pokedl", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_pokedl_meta_instruction_parameter_types },
1427 { 191, "pokedlu", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_pokedlu_meta_instruction_parameter_types },
1428 { 192, "pokei", 3, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_pokei_meta_instruction_parameter_types },
1429 { 193, "pokeiu", 2, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_pokeiu_meta_instruction_parameter_types },
1430 { 194, "pokel", 3, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_pokel_meta_instruction_parameter_types },
1431 { 195, "pokelu", 2, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_pokelu_meta_instruction_parameter_types },
1432 { 196, "pokes", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1433 { 197, "pope", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1434 { 198, "popend", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1435 { 199, "popf", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_popf_meta_instruction_parameter_types },
1436 { 200, "popios", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1437 { 201, "popoac", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1438 { 202, "popob", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1439 { 203, "popobc", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1440 { 204, "popoc", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1441 { 205, "popod", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1442 { 206, "popoi", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1443 { 207, "popom", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1444 { 208, "popoo", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1445 { 209, "popopp", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1446 { 210, "popr", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_popr_meta_instruction_parameter_types },
1447 { 211, "popvar", 2, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_popvar_meta_instruction_parameter_types },
1448 { 212, "powi", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1449 { 213, "powiu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1450 { 214, "powl", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1451 { 215, "powlu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1452 { 216, "printi", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_printi_meta_instruction_parameter_types },
1453 { 217, "printiu", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_printiu_meta_instruction_parameter_types },
1454 { 218, "printl", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_printl_meta_instruction_parameter_types },
1455 { 219, "printlu", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_printlu_meta_instruction_parameter_types },
1456 { 220, "prints", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1457 { 221, "prolog", 0, false, true, true /* FIXME: this may be wrong with replacements. */, NULL },
1458 { 222, "push", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_push_meta_instruction_parameter_types },
1459 { 223, "push32", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_push32_meta_instruction_parameter_types },
1460 { 224, "pushe", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_pushe_meta_instruction_parameter_types },
1461 { 225, "pushend", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1462 { 226, "pushf", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_pushf_meta_instruction_parameter_types },
1463 { 227, "pushhi", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_pushhi_meta_instruction_parameter_types },
1464 { 228, "pushios", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1465 { 229, "pushlo", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_pushlo_meta_instruction_parameter_types },
1466 { 230, "pushoac", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1467 { 231, "pushob", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1468 { 232, "pushobc", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1469 { 233, "pushoc", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1470 { 234, "pushod", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1471 { 235, "pushoi", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1472 { 236, "pushom", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1473 { 237, "pushoo", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1474 { 238, "pushopp", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1475 { 239, "pushr", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_pushr_meta_instruction_parameter_types },
1476 { 240, "pushtopvar", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_pushtopvar_meta_instruction_parameter_types },
1477 { 241, "pushvar", 2, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_pushvar_meta_instruction_parameter_types },
1478 { 242, "quake", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1479 { 243, "raise", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1480 { 244, "rand", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1481 { 245, "regvar", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1482 { 246, "reloc", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1483 { 247, "restorer", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_restorer_meta_instruction_parameter_types },
1484 { 248, "return", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1485 { 249, "revn", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_revn_meta_instruction_parameter_types },
1486 { 250, "rot", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1487 { 251, "saver", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_saver_meta_instruction_parameter_types },
1488 { 252, "sconc", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1489 { 253, "sel", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1490 { 254, "setr", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_setr_meta_instruction_parameter_types },
1491 { 255, "siz", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1492 { 256, "smodi", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1493 { 257, "sref", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1494 { 258, "srefi", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1495 { 259, "srefia", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1496 { 260, "srefio", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1497 { 261, "srefmnt", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1498 { 262, "srefnt", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1499 { 263, "srefo", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1500 { 264, "sset", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1501 { 265, "strace", 1, false, false, true /* FIXME: this may be wrong with replacements. */, pvm_strace_meta_instruction_parameter_types },
1502 { 266, "strref", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1503 { 267, "subi", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1504 { 268, "subiu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1505 { 269, "subl", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1506 { 270, "sublu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1507 { 271, "substr", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1508 { 272, "swap", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1509 { 273, "swapgti", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1510 { 274, "swapgtiu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1511 { 275, "swapgtl", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1512 { 276, "swapgtlu", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1513 { 277, "sync", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1514 { 278, "time", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1515 { 279, "tor", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1516 { 280, "tuck", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1517 { 281, "tyagetb", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1518 { 282, "tyagett", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1519 { 283, "tyisc", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1520 { 284, "tyissct", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1521 { 285, "typof", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1522 { 286, "tysctn", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1523 { 287, "unmap", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1524 { 288, "unreachable", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1525 { 289, "ureloc", 0, false, false, true /* FIXME: this may be wrong with replacements. */, NULL },
1526 { 290, "write", 0, true, false, true /* FIXME: this may be wrong with replacements. */, NULL }
1527 };
1528
1529 /* The register class descriptor for r registers. */
1530 const struct jitter_register_class
1531 pvm_register_class_r
1532 = {
1533 pvm_register_class_id_r,
1534 'r',
1535 "register_class_r",
1536 "REGISTER_CLASS_R",
1537 PVM_REGISTER_r_FAST_REGISTER_NO,
1538 1 /* Use slow registers */
1539 };
1540
1541
1542 /* A pointer to every existing register class descriptor. */
1543 const struct jitter_register_class * const
1544 pvm_regiter_classes []
1545 = {
1546 & pvm_register_class_r
1547 };
1548
1549 const struct jitter_register_class *
pvm_register_class_character_to_register_class(char c)1550 pvm_register_class_character_to_register_class (char c)
1551 {
1552 switch (c)
1553 {
1554 case 'r': return & pvm_register_class_r;
1555 default: return NULL;
1556 }
1557 }
1558
1559 //#include "pvm-specialized-instructions.h"
1560
1561 const char * const
1562 pvm_specialized_instruction_names [PVM_SPECIALIZED_INSTRUCTION_NO]
1563 = {
1564 "!INVALID",
1565 "!BEGINBASICBLOCK",
1566 "!EXITVM",
1567 "!DATALOCATIONS",
1568 "!NOP",
1569 "!UNREACHABLE0",
1570 "!UNREACHABLE1",
1571 "!UNREACHABLE2",
1572 "addi",
1573 "addiu",
1574 "addl",
1575 "addlu",
1576 "ains",
1577 "and",
1578 "aref",
1579 "arefo",
1580 "arem",
1581 "aset",
1582 "asettb",
1583 "atr",
1584 "ba/fR",
1585 "bandi",
1586 "bandiu",
1587 "bandl",
1588 "bandlu",
1589 "beghl",
1590 "begsc",
1591 "bn/fR",
1592 "bnn/fR",
1593 "bnoti",
1594 "bnotiu",
1595 "bnotl",
1596 "bnotlu",
1597 "bnzi/fR",
1598 "bnziu/fR",
1599 "bnzl/fR",
1600 "bnzlu/fR",
1601 "bori",
1602 "boriu",
1603 "borl",
1604 "borlu",
1605 "bsli",
1606 "bsliu",
1607 "bsll",
1608 "bsllu",
1609 "bsri",
1610 "bsriu",
1611 "bsrl",
1612 "bsrlu",
1613 "bxori",
1614 "bxoriu",
1615 "bxorl",
1616 "bxorlu",
1617 "bzi/fR",
1618 "bziu/fR",
1619 "bzl/fR",
1620 "bzlu/fR",
1621 "call/retR",
1622 "canary",
1623 "close",
1624 "ctos",
1625 "disas",
1626 "divi",
1627 "diviu",
1628 "divl",
1629 "divlu",
1630 "drop",
1631 "drop2",
1632 "drop3",
1633 "drop4",
1634 "duc",
1635 "dup",
1636 "endhl",
1637 "endsc",
1638 "eqi",
1639 "eqiu",
1640 "eql",
1641 "eqlu",
1642 "eqs",
1643 "exit",
1644 "exitvm",
1645 "flush",
1646 "fromr",
1647 "gei",
1648 "geiu",
1649 "gel",
1650 "gelu",
1651 "ges",
1652 "getenv",
1653 "gti",
1654 "gtiu",
1655 "gtl",
1656 "gtlu",
1657 "gts",
1658 "indent",
1659 "iogetb",
1660 "iosetb",
1661 "iosize",
1662 "isa",
1663 "itoi/nR",
1664 "itoiu/nR",
1665 "itol/nR",
1666 "itolu/nR",
1667 "iutoi/nR",
1668 "iutoiu/nR",
1669 "iutol/nR",
1670 "iutolu/nR",
1671 "lei",
1672 "leiu",
1673 "lel",
1674 "lelu",
1675 "les",
1676 "lti",
1677 "ltiu",
1678 "ltl",
1679 "ltlu",
1680 "ltoi/nR",
1681 "ltoiu/nR",
1682 "ltol/nR",
1683 "ltolu/nR",
1684 "lts",
1685 "lutoi/nR",
1686 "lutoiu/nR",
1687 "lutol/nR",
1688 "lutolu/nR",
1689 "map",
1690 "mgetios",
1691 "mgetm",
1692 "mgeto",
1693 "mgets",
1694 "mgetsel",
1695 "mgetsiz",
1696 "mgetw",
1697 "mka",
1698 "mko",
1699 "mksct",
1700 "mktya",
1701 "mktyany",
1702 "mktyc",
1703 "mktyi",
1704 "mktyo",
1705 "mktys",
1706 "mktysct",
1707 "mktyv",
1708 "mm",
1709 "modi",
1710 "modiu",
1711 "modl",
1712 "modlu",
1713 "msetios",
1714 "msetm",
1715 "mseto",
1716 "msets",
1717 "msetsel",
1718 "msetsiz",
1719 "msetw",
1720 "muli",
1721 "muliu",
1722 "mull",
1723 "mullu",
1724 "muls",
1725 "negi",
1726 "negiu",
1727 "negl",
1728 "neglu",
1729 "nei",
1730 "neiu",
1731 "nel",
1732 "nelu",
1733 "nes",
1734 "nip",
1735 "nip2",
1736 "nip3",
1737 "nn",
1738 "nnn",
1739 "nop",
1740 "not",
1741 "note/nR",
1742 "nrot",
1743 "ogetbt",
1744 "ogetm",
1745 "ogetu",
1746 "open",
1747 "or",
1748 "osetm",
1749 "over",
1750 "pec",
1751 "peekdi/nR",
1752 "peekdiu/nR",
1753 "peekdl/nR",
1754 "peekdlu/nR",
1755 "peeki/nR/nR/nR",
1756 "peekiu/nR/nR",
1757 "peekl/nR/nR/nR",
1758 "peeklu/nR/nR",
1759 "peeks",
1760 "pokedi/nR",
1761 "pokediu/nR",
1762 "pokedl/nR",
1763 "pokedlu/nR",
1764 "pokei/nR/nR/nR",
1765 "pokeiu/nR/nR",
1766 "pokel/nR/nR/nR",
1767 "pokelu/nR/nR",
1768 "pokes",
1769 "pope",
1770 "popend",
1771 "popf/nR",
1772 "popios",
1773 "popoac",
1774 "popob",
1775 "popobc",
1776 "popoc",
1777 "popod",
1778 "popoi",
1779 "popom",
1780 "popoo",
1781 "popopp",
1782 "popr/%rR",
1783 "popvar/nR/nR",
1784 "powi",
1785 "powiu",
1786 "powl",
1787 "powlu",
1788 "printi/nR",
1789 "printiu/nR",
1790 "printl/nR",
1791 "printlu/nR",
1792 "prints",
1793 "prolog",
1794 "push/nR",
1795 "push/lR",
1796 "push32/nR",
1797 "push32/lR",
1798 "pushe/lR",
1799 "pushend",
1800 "pushf/nR",
1801 "pushhi/nR",
1802 "pushhi/lR",
1803 "pushios",
1804 "pushlo/nR",
1805 "pushlo/lR",
1806 "pushoac",
1807 "pushob",
1808 "pushobc",
1809 "pushoc",
1810 "pushod",
1811 "pushoi",
1812 "pushom",
1813 "pushoo",
1814 "pushopp",
1815 "pushr/%rR",
1816 "pushtopvar/nR",
1817 "pushvar/n0/n0",
1818 "pushvar/n0/n1",
1819 "pushvar/n0/n2",
1820 "pushvar/n0/n3",
1821 "pushvar/n0/n4",
1822 "pushvar/n0/n5",
1823 "pushvar/n0/nR",
1824 "pushvar/nR/n0",
1825 "pushvar/nR/n1",
1826 "pushvar/nR/n2",
1827 "pushvar/nR/n3",
1828 "pushvar/nR/n4",
1829 "pushvar/nR/n5",
1830 "pushvar/nR/nR",
1831 "quake",
1832 "raise",
1833 "rand",
1834 "regvar",
1835 "reloc",
1836 "restorer/%rR",
1837 "return",
1838 "revn/n3",
1839 "revn/n4",
1840 "revn/nR",
1841 "rot",
1842 "saver/%rR",
1843 "sconc",
1844 "sel",
1845 "setr/%rR",
1846 "siz",
1847 "smodi",
1848 "sref",
1849 "srefi",
1850 "srefia",
1851 "srefio",
1852 "srefmnt",
1853 "srefnt",
1854 "srefo",
1855 "sset",
1856 "strace/nR",
1857 "strref",
1858 "subi",
1859 "subiu",
1860 "subl",
1861 "sublu",
1862 "substr",
1863 "swap",
1864 "swapgti",
1865 "swapgtiu",
1866 "swapgtl",
1867 "swapgtlu",
1868 "sync",
1869 "time",
1870 "tor",
1871 "tuck",
1872 "tyagetb",
1873 "tyagett",
1874 "tyisc",
1875 "tyissct",
1876 "typof",
1877 "tysctn",
1878 "unmap",
1879 "unreachable",
1880 "ureloc",
1881 "write/retR",
1882 "*ba/fR*-no-fast-branches",
1883 "*bn/fR*-no-fast-branches",
1884 "*bnn/fR*-no-fast-branches",
1885 "*bnzi/fR*-no-fast-branches",
1886 "*bnziu/fR*-no-fast-branches",
1887 "*bnzl/fR*-no-fast-branches",
1888 "*bnzlu/fR*-no-fast-branches",
1889 "*bzi/fR*-no-fast-branches",
1890 "*bziu/fR*-no-fast-branches",
1891 "*bzl/fR*-no-fast-branches",
1892 "*bzlu/fR*-no-fast-branches"
1893 };
1894 // #include <stdlib.h>
1895
1896 // #include "pvm-specialized-instructions.h"
1897 const size_t
1898 pvm_specialized_instruction_residual_arities [PVM_SPECIALIZED_INSTRUCTION_NO]
1899 = {
1900 0, /* !INVALID */
1901 1, /* !BEGINBASICBLOCK */
1902 0, /* !EXITVM */
1903 0, /* !DATALOCATIONS */
1904 0, /* !NOP */
1905 0, /* !UNREACHABLE0 */
1906 0, /* !UNREACHABLE1 */
1907 0, /* !UNREACHABLE2 */
1908 0, /* addi */
1909 0, /* addiu */
1910 0, /* addl */
1911 0, /* addlu */
1912 0, /* ains */
1913 0, /* and */
1914 0, /* aref */
1915 0, /* arefo */
1916 0, /* arem */
1917 0, /* aset */
1918 0, /* asettb */
1919 0, /* atr */
1920 1, /* ba/fR */
1921 0, /* bandi */
1922 0, /* bandiu */
1923 0, /* bandl */
1924 0, /* bandlu */
1925 0, /* beghl */
1926 0, /* begsc */
1927 1, /* bn/fR */
1928 1, /* bnn/fR */
1929 0, /* bnoti */
1930 0, /* bnotiu */
1931 0, /* bnotl */
1932 0, /* bnotlu */
1933 1, /* bnzi/fR */
1934 1, /* bnziu/fR */
1935 1, /* bnzl/fR */
1936 1, /* bnzlu/fR */
1937 0, /* bori */
1938 0, /* boriu */
1939 0, /* borl */
1940 0, /* borlu */
1941 0, /* bsli */
1942 0, /* bsliu */
1943 0, /* bsll */
1944 0, /* bsllu */
1945 0, /* bsri */
1946 0, /* bsriu */
1947 0, /* bsrl */
1948 0, /* bsrlu */
1949 0, /* bxori */
1950 0, /* bxoriu */
1951 0, /* bxorl */
1952 0, /* bxorlu */
1953 1, /* bzi/fR */
1954 1, /* bziu/fR */
1955 1, /* bzl/fR */
1956 1, /* bzlu/fR */
1957 1, /* call/retR */
1958 0, /* canary */
1959 0, /* close */
1960 0, /* ctos */
1961 0, /* disas */
1962 0, /* divi */
1963 0, /* diviu */
1964 0, /* divl */
1965 0, /* divlu */
1966 0, /* drop */
1967 0, /* drop2 */
1968 0, /* drop3 */
1969 0, /* drop4 */
1970 0, /* duc */
1971 0, /* dup */
1972 0, /* endhl */
1973 0, /* endsc */
1974 0, /* eqi */
1975 0, /* eqiu */
1976 0, /* eql */
1977 0, /* eqlu */
1978 0, /* eqs */
1979 0, /* exit */
1980 0, /* exitvm */
1981 0, /* flush */
1982 0, /* fromr */
1983 0, /* gei */
1984 0, /* geiu */
1985 0, /* gel */
1986 0, /* gelu */
1987 0, /* ges */
1988 0, /* getenv */
1989 0, /* gti */
1990 0, /* gtiu */
1991 0, /* gtl */
1992 0, /* gtlu */
1993 0, /* gts */
1994 0, /* indent */
1995 0, /* iogetb */
1996 0, /* iosetb */
1997 0, /* iosize */
1998 0, /* isa */
1999 1, /* itoi/nR */
2000 1, /* itoiu/nR */
2001 1, /* itol/nR */
2002 1, /* itolu/nR */
2003 1, /* iutoi/nR */
2004 1, /* iutoiu/nR */
2005 1, /* iutol/nR */
2006 1, /* iutolu/nR */
2007 0, /* lei */
2008 0, /* leiu */
2009 0, /* lel */
2010 0, /* lelu */
2011 0, /* les */
2012 0, /* lti */
2013 0, /* ltiu */
2014 0, /* ltl */
2015 0, /* ltlu */
2016 1, /* ltoi/nR */
2017 1, /* ltoiu/nR */
2018 1, /* ltol/nR */
2019 1, /* ltolu/nR */
2020 0, /* lts */
2021 1, /* lutoi/nR */
2022 1, /* lutoiu/nR */
2023 1, /* lutol/nR */
2024 1, /* lutolu/nR */
2025 0, /* map */
2026 0, /* mgetios */
2027 0, /* mgetm */
2028 0, /* mgeto */
2029 0, /* mgets */
2030 0, /* mgetsel */
2031 0, /* mgetsiz */
2032 0, /* mgetw */
2033 0, /* mka */
2034 0, /* mko */
2035 0, /* mksct */
2036 0, /* mktya */
2037 0, /* mktyany */
2038 0, /* mktyc */
2039 0, /* mktyi */
2040 0, /* mktyo */
2041 0, /* mktys */
2042 0, /* mktysct */
2043 0, /* mktyv */
2044 0, /* mm */
2045 0, /* modi */
2046 0, /* modiu */
2047 0, /* modl */
2048 0, /* modlu */
2049 0, /* msetios */
2050 0, /* msetm */
2051 0, /* mseto */
2052 0, /* msets */
2053 0, /* msetsel */
2054 0, /* msetsiz */
2055 0, /* msetw */
2056 0, /* muli */
2057 0, /* muliu */
2058 0, /* mull */
2059 0, /* mullu */
2060 0, /* muls */
2061 0, /* negi */
2062 0, /* negiu */
2063 0, /* negl */
2064 0, /* neglu */
2065 0, /* nei */
2066 0, /* neiu */
2067 0, /* nel */
2068 0, /* nelu */
2069 0, /* nes */
2070 0, /* nip */
2071 0, /* nip2 */
2072 0, /* nip3 */
2073 0, /* nn */
2074 0, /* nnn */
2075 0, /* nop */
2076 0, /* not */
2077 1, /* note/nR */
2078 0, /* nrot */
2079 0, /* ogetbt */
2080 0, /* ogetm */
2081 0, /* ogetu */
2082 0, /* open */
2083 0, /* or */
2084 0, /* osetm */
2085 0, /* over */
2086 0, /* pec */
2087 1, /* peekdi/nR */
2088 1, /* peekdiu/nR */
2089 1, /* peekdl/nR */
2090 1, /* peekdlu/nR */
2091 3, /* peeki/nR/nR/nR */
2092 2, /* peekiu/nR/nR */
2093 3, /* peekl/nR/nR/nR */
2094 2, /* peeklu/nR/nR */
2095 0, /* peeks */
2096 1, /* pokedi/nR */
2097 1, /* pokediu/nR */
2098 1, /* pokedl/nR */
2099 1, /* pokedlu/nR */
2100 3, /* pokei/nR/nR/nR */
2101 2, /* pokeiu/nR/nR */
2102 3, /* pokel/nR/nR/nR */
2103 2, /* pokelu/nR/nR */
2104 0, /* pokes */
2105 0, /* pope */
2106 0, /* popend */
2107 1, /* popf/nR */
2108 0, /* popios */
2109 0, /* popoac */
2110 0, /* popob */
2111 0, /* popobc */
2112 0, /* popoc */
2113 0, /* popod */
2114 0, /* popoi */
2115 0, /* popom */
2116 0, /* popoo */
2117 0, /* popopp */
2118 1, /* popr/%rR */
2119 2, /* popvar/nR/nR */
2120 0, /* powi */
2121 0, /* powiu */
2122 0, /* powl */
2123 0, /* powlu */
2124 1, /* printi/nR */
2125 1, /* printiu/nR */
2126 1, /* printl/nR */
2127 1, /* printlu/nR */
2128 0, /* prints */
2129 0, /* prolog */
2130 1, /* push/nR */
2131 1, /* push/lR */
2132 1, /* push32/nR */
2133 1, /* push32/lR */
2134 1, /* pushe/lR */
2135 0, /* pushend */
2136 1, /* pushf/nR */
2137 1, /* pushhi/nR */
2138 1, /* pushhi/lR */
2139 0, /* pushios */
2140 1, /* pushlo/nR */
2141 1, /* pushlo/lR */
2142 0, /* pushoac */
2143 0, /* pushob */
2144 0, /* pushobc */
2145 0, /* pushoc */
2146 0, /* pushod */
2147 0, /* pushoi */
2148 0, /* pushom */
2149 0, /* pushoo */
2150 0, /* pushopp */
2151 1, /* pushr/%rR */
2152 1, /* pushtopvar/nR */
2153 0, /* pushvar/n0/n0 */
2154 0, /* pushvar/n0/n1 */
2155 0, /* pushvar/n0/n2 */
2156 0, /* pushvar/n0/n3 */
2157 0, /* pushvar/n0/n4 */
2158 0, /* pushvar/n0/n5 */
2159 1, /* pushvar/n0/nR */
2160 1, /* pushvar/nR/n0 */
2161 1, /* pushvar/nR/n1 */
2162 1, /* pushvar/nR/n2 */
2163 1, /* pushvar/nR/n3 */
2164 1, /* pushvar/nR/n4 */
2165 1, /* pushvar/nR/n5 */
2166 2, /* pushvar/nR/nR */
2167 0, /* quake */
2168 0, /* raise */
2169 0, /* rand */
2170 0, /* regvar */
2171 0, /* reloc */
2172 1, /* restorer/%rR */
2173 0, /* return */
2174 0, /* revn/n3 */
2175 0, /* revn/n4 */
2176 1, /* revn/nR */
2177 0, /* rot */
2178 1, /* saver/%rR */
2179 0, /* sconc */
2180 0, /* sel */
2181 1, /* setr/%rR */
2182 0, /* siz */
2183 0, /* smodi */
2184 0, /* sref */
2185 0, /* srefi */
2186 0, /* srefia */
2187 0, /* srefio */
2188 0, /* srefmnt */
2189 0, /* srefnt */
2190 0, /* srefo */
2191 0, /* sset */
2192 1, /* strace/nR */
2193 0, /* strref */
2194 0, /* subi */
2195 0, /* subiu */
2196 0, /* subl */
2197 0, /* sublu */
2198 0, /* substr */
2199 0, /* swap */
2200 0, /* swapgti */
2201 0, /* swapgtiu */
2202 0, /* swapgtl */
2203 0, /* swapgtlu */
2204 0, /* sync */
2205 0, /* time */
2206 0, /* tor */
2207 0, /* tuck */
2208 0, /* tyagetb */
2209 0, /* tyagett */
2210 0, /* tyisc */
2211 0, /* tyissct */
2212 0, /* typof */
2213 0, /* tysctn */
2214 0, /* unmap */
2215 0, /* unreachable */
2216 0, /* ureloc */
2217 1, /* write/retR */
2218 1, /* *ba/fR*-no-fast-branches */
2219 1, /* *bn/fR*-no-fast-branches */
2220 1, /* *bnn/fR*-no-fast-branches */
2221 1, /* *bnzi/fR*-no-fast-branches */
2222 1, /* *bnziu/fR*-no-fast-branches */
2223 1, /* *bnzl/fR*-no-fast-branches */
2224 1, /* *bnzlu/fR*-no-fast-branches */
2225 1, /* *bzi/fR*-no-fast-branches */
2226 1, /* *bziu/fR*-no-fast-branches */
2227 1, /* *bzl/fR*-no-fast-branches */
2228 1 /* *bzlu/fR*-no-fast-branches */
2229 };
2230 const unsigned long // FIXME: shall I use a shorter type when possible?
2231 pvm_specialized_instruction_label_bitmasks [PVM_SPECIALIZED_INSTRUCTION_NO]
2232 = {
2233 /* It's important that !BEGINBASICBLOCK has a zero here: it does not need residual patching. */
2234 0, /* !INVALID */
2235 0, /* !BEGINBASICBLOCK */
2236 0, /* !EXITVM */
2237 0, /* !DATALOCATIONS */
2238 0, /* !NOP */
2239 0, /* !UNREACHABLE0 */
2240 0, /* !UNREACHABLE1 */
2241 0, /* !UNREACHABLE2 */
2242 0, /* addi */
2243 0, /* addiu */
2244 0, /* addl */
2245 0, /* addlu */
2246 0, /* ains */
2247 0, /* and */
2248 0, /* aref */
2249 0, /* arefo */
2250 0, /* arem */
2251 0, /* aset */
2252 0, /* asettb */
2253 0, /* atr */
2254 0 | (1UL << 0), /* ba/fR */
2255 0, /* bandi */
2256 0, /* bandiu */
2257 0, /* bandl */
2258 0, /* bandlu */
2259 0, /* beghl */
2260 0, /* begsc */
2261 0 | (1UL << 0), /* bn/fR */
2262 0 | (1UL << 0), /* bnn/fR */
2263 0, /* bnoti */
2264 0, /* bnotiu */
2265 0, /* bnotl */
2266 0, /* bnotlu */
2267 0 | (1UL << 0), /* bnzi/fR */
2268 0 | (1UL << 0), /* bnziu/fR */
2269 0 | (1UL << 0), /* bnzl/fR */
2270 0 | (1UL << 0), /* bnzlu/fR */
2271 0, /* bori */
2272 0, /* boriu */
2273 0, /* borl */
2274 0, /* borlu */
2275 0, /* bsli */
2276 0, /* bsliu */
2277 0, /* bsll */
2278 0, /* bsllu */
2279 0, /* bsri */
2280 0, /* bsriu */
2281 0, /* bsrl */
2282 0, /* bsrlu */
2283 0, /* bxori */
2284 0, /* bxoriu */
2285 0, /* bxorl */
2286 0, /* bxorlu */
2287 0 | (1UL << 0), /* bzi/fR */
2288 0 | (1UL << 0), /* bziu/fR */
2289 0 | (1UL << 0), /* bzl/fR */
2290 0 | (1UL << 0), /* bzlu/fR */
2291 0, /* call/retR */
2292 0, /* canary */
2293 0, /* close */
2294 0, /* ctos */
2295 0, /* disas */
2296 0, /* divi */
2297 0, /* diviu */
2298 0, /* divl */
2299 0, /* divlu */
2300 0, /* drop */
2301 0, /* drop2 */
2302 0, /* drop3 */
2303 0, /* drop4 */
2304 0, /* duc */
2305 0, /* dup */
2306 0, /* endhl */
2307 0, /* endsc */
2308 0, /* eqi */
2309 0, /* eqiu */
2310 0, /* eql */
2311 0, /* eqlu */
2312 0, /* eqs */
2313 0, /* exit */
2314 0, /* exitvm */
2315 0, /* flush */
2316 0, /* fromr */
2317 0, /* gei */
2318 0, /* geiu */
2319 0, /* gel */
2320 0, /* gelu */
2321 0, /* ges */
2322 0, /* getenv */
2323 0, /* gti */
2324 0, /* gtiu */
2325 0, /* gtl */
2326 0, /* gtlu */
2327 0, /* gts */
2328 0, /* indent */
2329 0, /* iogetb */
2330 0, /* iosetb */
2331 0, /* iosize */
2332 0, /* isa */
2333 0, /* itoi/nR */
2334 0, /* itoiu/nR */
2335 0, /* itol/nR */
2336 0, /* itolu/nR */
2337 0, /* iutoi/nR */
2338 0, /* iutoiu/nR */
2339 0, /* iutol/nR */
2340 0, /* iutolu/nR */
2341 0, /* lei */
2342 0, /* leiu */
2343 0, /* lel */
2344 0, /* lelu */
2345 0, /* les */
2346 0, /* lti */
2347 0, /* ltiu */
2348 0, /* ltl */
2349 0, /* ltlu */
2350 0, /* ltoi/nR */
2351 0, /* ltoiu/nR */
2352 0, /* ltol/nR */
2353 0, /* ltolu/nR */
2354 0, /* lts */
2355 0, /* lutoi/nR */
2356 0, /* lutoiu/nR */
2357 0, /* lutol/nR */
2358 0, /* lutolu/nR */
2359 0, /* map */
2360 0, /* mgetios */
2361 0, /* mgetm */
2362 0, /* mgeto */
2363 0, /* mgets */
2364 0, /* mgetsel */
2365 0, /* mgetsiz */
2366 0, /* mgetw */
2367 0, /* mka */
2368 0, /* mko */
2369 0, /* mksct */
2370 0, /* mktya */
2371 0, /* mktyany */
2372 0, /* mktyc */
2373 0, /* mktyi */
2374 0, /* mktyo */
2375 0, /* mktys */
2376 0, /* mktysct */
2377 0, /* mktyv */
2378 0, /* mm */
2379 0, /* modi */
2380 0, /* modiu */
2381 0, /* modl */
2382 0, /* modlu */
2383 0, /* msetios */
2384 0, /* msetm */
2385 0, /* mseto */
2386 0, /* msets */
2387 0, /* msetsel */
2388 0, /* msetsiz */
2389 0, /* msetw */
2390 0, /* muli */
2391 0, /* muliu */
2392 0, /* mull */
2393 0, /* mullu */
2394 0, /* muls */
2395 0, /* negi */
2396 0, /* negiu */
2397 0, /* negl */
2398 0, /* neglu */
2399 0, /* nei */
2400 0, /* neiu */
2401 0, /* nel */
2402 0, /* nelu */
2403 0, /* nes */
2404 0, /* nip */
2405 0, /* nip2 */
2406 0, /* nip3 */
2407 0, /* nn */
2408 0, /* nnn */
2409 0, /* nop */
2410 0, /* not */
2411 0, /* note/nR */
2412 0, /* nrot */
2413 0, /* ogetbt */
2414 0, /* ogetm */
2415 0, /* ogetu */
2416 0, /* open */
2417 0, /* or */
2418 0, /* osetm */
2419 0, /* over */
2420 0, /* pec */
2421 0, /* peekdi/nR */
2422 0, /* peekdiu/nR */
2423 0, /* peekdl/nR */
2424 0, /* peekdlu/nR */
2425 0, /* peeki/nR/nR/nR */
2426 0, /* peekiu/nR/nR */
2427 0, /* peekl/nR/nR/nR */
2428 0, /* peeklu/nR/nR */
2429 0, /* peeks */
2430 0, /* pokedi/nR */
2431 0, /* pokediu/nR */
2432 0, /* pokedl/nR */
2433 0, /* pokedlu/nR */
2434 0, /* pokei/nR/nR/nR */
2435 0, /* pokeiu/nR/nR */
2436 0, /* pokel/nR/nR/nR */
2437 0, /* pokelu/nR/nR */
2438 0, /* pokes */
2439 0, /* pope */
2440 0, /* popend */
2441 0, /* popf/nR */
2442 0, /* popios */
2443 0, /* popoac */
2444 0, /* popob */
2445 0, /* popobc */
2446 0, /* popoc */
2447 0, /* popod */
2448 0, /* popoi */
2449 0, /* popom */
2450 0, /* popoo */
2451 0, /* popopp */
2452 0, /* popr/%rR */
2453 0, /* popvar/nR/nR */
2454 0, /* powi */
2455 0, /* powiu */
2456 0, /* powl */
2457 0, /* powlu */
2458 0, /* printi/nR */
2459 0, /* printiu/nR */
2460 0, /* printl/nR */
2461 0, /* printlu/nR */
2462 0, /* prints */
2463 0, /* prolog */
2464 0, /* push/nR */
2465 0 | (1UL << 0), /* push/lR */
2466 0, /* push32/nR */
2467 0 | (1UL << 0), /* push32/lR */
2468 0 | (1UL << 0), /* pushe/lR */
2469 0, /* pushend */
2470 0, /* pushf/nR */
2471 0, /* pushhi/nR */
2472 0 | (1UL << 0), /* pushhi/lR */
2473 0, /* pushios */
2474 0, /* pushlo/nR */
2475 0 | (1UL << 0), /* pushlo/lR */
2476 0, /* pushoac */
2477 0, /* pushob */
2478 0, /* pushobc */
2479 0, /* pushoc */
2480 0, /* pushod */
2481 0, /* pushoi */
2482 0, /* pushom */
2483 0, /* pushoo */
2484 0, /* pushopp */
2485 0, /* pushr/%rR */
2486 0, /* pushtopvar/nR */
2487 0, /* pushvar/n0/n0 */
2488 0, /* pushvar/n0/n1 */
2489 0, /* pushvar/n0/n2 */
2490 0, /* pushvar/n0/n3 */
2491 0, /* pushvar/n0/n4 */
2492 0, /* pushvar/n0/n5 */
2493 0, /* pushvar/n0/nR */
2494 0, /* pushvar/nR/n0 */
2495 0, /* pushvar/nR/n1 */
2496 0, /* pushvar/nR/n2 */
2497 0, /* pushvar/nR/n3 */
2498 0, /* pushvar/nR/n4 */
2499 0, /* pushvar/nR/n5 */
2500 0, /* pushvar/nR/nR */
2501 0, /* quake */
2502 0, /* raise */
2503 0, /* rand */
2504 0, /* regvar */
2505 0, /* reloc */
2506 0, /* restorer/%rR */
2507 0, /* return */
2508 0, /* revn/n3 */
2509 0, /* revn/n4 */
2510 0, /* revn/nR */
2511 0, /* rot */
2512 0, /* saver/%rR */
2513 0, /* sconc */
2514 0, /* sel */
2515 0, /* setr/%rR */
2516 0, /* siz */
2517 0, /* smodi */
2518 0, /* sref */
2519 0, /* srefi */
2520 0, /* srefia */
2521 0, /* srefio */
2522 0, /* srefmnt */
2523 0, /* srefnt */
2524 0, /* srefo */
2525 0, /* sset */
2526 0, /* strace/nR */
2527 0, /* strref */
2528 0, /* subi */
2529 0, /* subiu */
2530 0, /* subl */
2531 0, /* sublu */
2532 0, /* substr */
2533 0, /* swap */
2534 0, /* swapgti */
2535 0, /* swapgtiu */
2536 0, /* swapgtl */
2537 0, /* swapgtlu */
2538 0, /* sync */
2539 0, /* time */
2540 0, /* tor */
2541 0, /* tuck */
2542 0, /* tyagetb */
2543 0, /* tyagett */
2544 0, /* tyisc */
2545 0, /* tyissct */
2546 0, /* typof */
2547 0, /* tysctn */
2548 0, /* unmap */
2549 0, /* unreachable */
2550 0, /* ureloc */
2551 0, /* write/retR */
2552 0 | (1UL << 0), /* *ba/fR*-no-fast-branches */
2553 0 | (1UL << 0), /* *bn/fR*-no-fast-branches */
2554 0 | (1UL << 0), /* *bnn/fR*-no-fast-branches */
2555 0 | (1UL << 0), /* *bnzi/fR*-no-fast-branches */
2556 0 | (1UL << 0), /* *bnziu/fR*-no-fast-branches */
2557 0 | (1UL << 0), /* *bnzl/fR*-no-fast-branches */
2558 0 | (1UL << 0), /* *bnzlu/fR*-no-fast-branches */
2559 0 | (1UL << 0), /* *bzi/fR*-no-fast-branches */
2560 0 | (1UL << 0), /* *bziu/fR*-no-fast-branches */
2561 0 | (1UL << 0), /* *bzl/fR*-no-fast-branches */
2562 0 | (1UL << 0) /* *bzlu/fR*-no-fast-branches */
2563 };
2564 #ifdef JITTER_HAVE_PATCH_IN
2565 const unsigned long // FIXME: shall I use a shorter type when possible?
2566 pvm_specialized_instruction_fast_label_bitmasks [PVM_SPECIALIZED_INSTRUCTION_NO]
2567 = {
2568 /* It's important that !BEGINBASICBLOCK has a zero here: it does not need residual patching. */
2569 0, /* !INVALID */
2570 0, /* !BEGINBASICBLOCK */
2571 0, /* !EXITVM */
2572 0, /* !DATALOCATIONS */
2573 0, /* !NOP */
2574 0, /* !UNREACHABLE0 */
2575 0, /* !UNREACHABLE1 */
2576 0, /* !UNREACHABLE2 */
2577 0, /* addi */
2578 0, /* addiu */
2579 0, /* addl */
2580 0, /* addlu */
2581 0, /* ains */
2582 0, /* and */
2583 0, /* aref */
2584 0, /* arefo */
2585 0, /* arem */
2586 0, /* aset */
2587 0, /* asettb */
2588 0, /* atr */
2589 0 | (1UL << 0), /* ba/fR */
2590 0, /* bandi */
2591 0, /* bandiu */
2592 0, /* bandl */
2593 0, /* bandlu */
2594 0, /* beghl */
2595 0, /* begsc */
2596 0 | (1UL << 0), /* bn/fR */
2597 0 | (1UL << 0), /* bnn/fR */
2598 0, /* bnoti */
2599 0, /* bnotiu */
2600 0, /* bnotl */
2601 0, /* bnotlu */
2602 0 | (1UL << 0), /* bnzi/fR */
2603 0 | (1UL << 0), /* bnziu/fR */
2604 0 | (1UL << 0), /* bnzl/fR */
2605 0 | (1UL << 0), /* bnzlu/fR */
2606 0, /* bori */
2607 0, /* boriu */
2608 0, /* borl */
2609 0, /* borlu */
2610 0, /* bsli */
2611 0, /* bsliu */
2612 0, /* bsll */
2613 0, /* bsllu */
2614 0, /* bsri */
2615 0, /* bsriu */
2616 0, /* bsrl */
2617 0, /* bsrlu */
2618 0, /* bxori */
2619 0, /* bxoriu */
2620 0, /* bxorl */
2621 0, /* bxorlu */
2622 0 | (1UL << 0), /* bzi/fR */
2623 0 | (1UL << 0), /* bziu/fR */
2624 0 | (1UL << 0), /* bzl/fR */
2625 0 | (1UL << 0), /* bzlu/fR */
2626 0, /* call/retR */
2627 0, /* canary */
2628 0, /* close */
2629 0, /* ctos */
2630 0, /* disas */
2631 0, /* divi */
2632 0, /* diviu */
2633 0, /* divl */
2634 0, /* divlu */
2635 0, /* drop */
2636 0, /* drop2 */
2637 0, /* drop3 */
2638 0, /* drop4 */
2639 0, /* duc */
2640 0, /* dup */
2641 0, /* endhl */
2642 0, /* endsc */
2643 0, /* eqi */
2644 0, /* eqiu */
2645 0, /* eql */
2646 0, /* eqlu */
2647 0, /* eqs */
2648 0, /* exit */
2649 0, /* exitvm */
2650 0, /* flush */
2651 0, /* fromr */
2652 0, /* gei */
2653 0, /* geiu */
2654 0, /* gel */
2655 0, /* gelu */
2656 0, /* ges */
2657 0, /* getenv */
2658 0, /* gti */
2659 0, /* gtiu */
2660 0, /* gtl */
2661 0, /* gtlu */
2662 0, /* gts */
2663 0, /* indent */
2664 0, /* iogetb */
2665 0, /* iosetb */
2666 0, /* iosize */
2667 0, /* isa */
2668 0, /* itoi/nR */
2669 0, /* itoiu/nR */
2670 0, /* itol/nR */
2671 0, /* itolu/nR */
2672 0, /* iutoi/nR */
2673 0, /* iutoiu/nR */
2674 0, /* iutol/nR */
2675 0, /* iutolu/nR */
2676 0, /* lei */
2677 0, /* leiu */
2678 0, /* lel */
2679 0, /* lelu */
2680 0, /* les */
2681 0, /* lti */
2682 0, /* ltiu */
2683 0, /* ltl */
2684 0, /* ltlu */
2685 0, /* ltoi/nR */
2686 0, /* ltoiu/nR */
2687 0, /* ltol/nR */
2688 0, /* ltolu/nR */
2689 0, /* lts */
2690 0, /* lutoi/nR */
2691 0, /* lutoiu/nR */
2692 0, /* lutol/nR */
2693 0, /* lutolu/nR */
2694 0, /* map */
2695 0, /* mgetios */
2696 0, /* mgetm */
2697 0, /* mgeto */
2698 0, /* mgets */
2699 0, /* mgetsel */
2700 0, /* mgetsiz */
2701 0, /* mgetw */
2702 0, /* mka */
2703 0, /* mko */
2704 0, /* mksct */
2705 0, /* mktya */
2706 0, /* mktyany */
2707 0, /* mktyc */
2708 0, /* mktyi */
2709 0, /* mktyo */
2710 0, /* mktys */
2711 0, /* mktysct */
2712 0, /* mktyv */
2713 0, /* mm */
2714 0, /* modi */
2715 0, /* modiu */
2716 0, /* modl */
2717 0, /* modlu */
2718 0, /* msetios */
2719 0, /* msetm */
2720 0, /* mseto */
2721 0, /* msets */
2722 0, /* msetsel */
2723 0, /* msetsiz */
2724 0, /* msetw */
2725 0, /* muli */
2726 0, /* muliu */
2727 0, /* mull */
2728 0, /* mullu */
2729 0, /* muls */
2730 0, /* negi */
2731 0, /* negiu */
2732 0, /* negl */
2733 0, /* neglu */
2734 0, /* nei */
2735 0, /* neiu */
2736 0, /* nel */
2737 0, /* nelu */
2738 0, /* nes */
2739 0, /* nip */
2740 0, /* nip2 */
2741 0, /* nip3 */
2742 0, /* nn */
2743 0, /* nnn */
2744 0, /* nop */
2745 0, /* not */
2746 0, /* note/nR */
2747 0, /* nrot */
2748 0, /* ogetbt */
2749 0, /* ogetm */
2750 0, /* ogetu */
2751 0, /* open */
2752 0, /* or */
2753 0, /* osetm */
2754 0, /* over */
2755 0, /* pec */
2756 0, /* peekdi/nR */
2757 0, /* peekdiu/nR */
2758 0, /* peekdl/nR */
2759 0, /* peekdlu/nR */
2760 0, /* peeki/nR/nR/nR */
2761 0, /* peekiu/nR/nR */
2762 0, /* peekl/nR/nR/nR */
2763 0, /* peeklu/nR/nR */
2764 0, /* peeks */
2765 0, /* pokedi/nR */
2766 0, /* pokediu/nR */
2767 0, /* pokedl/nR */
2768 0, /* pokedlu/nR */
2769 0, /* pokei/nR/nR/nR */
2770 0, /* pokeiu/nR/nR */
2771 0, /* pokel/nR/nR/nR */
2772 0, /* pokelu/nR/nR */
2773 0, /* pokes */
2774 0, /* pope */
2775 0, /* popend */
2776 0, /* popf/nR */
2777 0, /* popios */
2778 0, /* popoac */
2779 0, /* popob */
2780 0, /* popobc */
2781 0, /* popoc */
2782 0, /* popod */
2783 0, /* popoi */
2784 0, /* popom */
2785 0, /* popoo */
2786 0, /* popopp */
2787 0, /* popr/%rR */
2788 0, /* popvar/nR/nR */
2789 0, /* powi */
2790 0, /* powiu */
2791 0, /* powl */
2792 0, /* powlu */
2793 0, /* printi/nR */
2794 0, /* printiu/nR */
2795 0, /* printl/nR */
2796 0, /* printlu/nR */
2797 0, /* prints */
2798 0, /* prolog */
2799 0, /* push/nR */
2800 0, /* push/lR */
2801 0, /* push32/nR */
2802 0, /* push32/lR */
2803 0, /* pushe/lR */
2804 0, /* pushend */
2805 0, /* pushf/nR */
2806 0, /* pushhi/nR */
2807 0, /* pushhi/lR */
2808 0, /* pushios */
2809 0, /* pushlo/nR */
2810 0, /* pushlo/lR */
2811 0, /* pushoac */
2812 0, /* pushob */
2813 0, /* pushobc */
2814 0, /* pushoc */
2815 0, /* pushod */
2816 0, /* pushoi */
2817 0, /* pushom */
2818 0, /* pushoo */
2819 0, /* pushopp */
2820 0, /* pushr/%rR */
2821 0, /* pushtopvar/nR */
2822 0, /* pushvar/n0/n0 */
2823 0, /* pushvar/n0/n1 */
2824 0, /* pushvar/n0/n2 */
2825 0, /* pushvar/n0/n3 */
2826 0, /* pushvar/n0/n4 */
2827 0, /* pushvar/n0/n5 */
2828 0, /* pushvar/n0/nR */
2829 0, /* pushvar/nR/n0 */
2830 0, /* pushvar/nR/n1 */
2831 0, /* pushvar/nR/n2 */
2832 0, /* pushvar/nR/n3 */
2833 0, /* pushvar/nR/n4 */
2834 0, /* pushvar/nR/n5 */
2835 0, /* pushvar/nR/nR */
2836 0, /* quake */
2837 0, /* raise */
2838 0, /* rand */
2839 0, /* regvar */
2840 0, /* reloc */
2841 0, /* restorer/%rR */
2842 0, /* return */
2843 0, /* revn/n3 */
2844 0, /* revn/n4 */
2845 0, /* revn/nR */
2846 0, /* rot */
2847 0, /* saver/%rR */
2848 0, /* sconc */
2849 0, /* sel */
2850 0, /* setr/%rR */
2851 0, /* siz */
2852 0, /* smodi */
2853 0, /* sref */
2854 0, /* srefi */
2855 0, /* srefia */
2856 0, /* srefio */
2857 0, /* srefmnt */
2858 0, /* srefnt */
2859 0, /* srefo */
2860 0, /* sset */
2861 0, /* strace/nR */
2862 0, /* strref */
2863 0, /* subi */
2864 0, /* subiu */
2865 0, /* subl */
2866 0, /* sublu */
2867 0, /* substr */
2868 0, /* swap */
2869 0, /* swapgti */
2870 0, /* swapgtiu */
2871 0, /* swapgtl */
2872 0, /* swapgtlu */
2873 0, /* sync */
2874 0, /* time */
2875 0, /* tor */
2876 0, /* tuck */
2877 0, /* tyagetb */
2878 0, /* tyagett */
2879 0, /* tyisc */
2880 0, /* tyissct */
2881 0, /* typof */
2882 0, /* tysctn */
2883 0, /* unmap */
2884 0, /* unreachable */
2885 0, /* ureloc */
2886 0, /* write/retR */
2887 0, /* *ba/fR*-no-fast-branches */
2888 0, /* *bn/fR*-no-fast-branches */
2889 0, /* *bnn/fR*-no-fast-branches */
2890 0, /* *bnzi/fR*-no-fast-branches */
2891 0, /* *bnziu/fR*-no-fast-branches */
2892 0, /* *bnzl/fR*-no-fast-branches */
2893 0, /* *bnzlu/fR*-no-fast-branches */
2894 0, /* *bzi/fR*-no-fast-branches */
2895 0, /* *bziu/fR*-no-fast-branches */
2896 0, /* *bzl/fR*-no-fast-branches */
2897 0 /* *bzlu/fR*-no-fast-branches */
2898 };
2899 #endif // #ifdef JITTER_HAVE_PATCH_IN
2900
2901 // FIXME: I may want to conditionalize this.
2902 const bool
2903 pvm_specialized_instruction_relocatables [PVM_SPECIALIZED_INSTRUCTION_NO]
2904 = {
2905 true, // !INVALID
2906 true, // !BEGINBASICBLOCK
2907 true, // !EXITVM
2908 true, // !DATALOCATIONS
2909 true, // !NOP
2910 true, // !UNREACHABLE0
2911 true, // !UNREACHABLE1
2912 true, // !UNREACHABLE2
2913 true, // addi
2914 true, // addiu
2915 true, // addl
2916 true, // addlu
2917 true, // ains
2918 true, // and
2919 true, // aref
2920 true, // arefo
2921 true, // arem
2922 true, // aset
2923 true, // asettb
2924 true, // atr
2925 true, // ba/fR
2926 true, // bandi
2927 true, // bandiu
2928 true, // bandl
2929 true, // bandlu
2930 true, // beghl
2931 true, // begsc
2932 true, // bn/fR
2933 true, // bnn/fR
2934 true, // bnoti
2935 true, // bnotiu
2936 true, // bnotl
2937 true, // bnotlu
2938 true, // bnzi/fR
2939 true, // bnziu/fR
2940 true, // bnzl/fR
2941 true, // bnzlu/fR
2942 true, // bori
2943 true, // boriu
2944 true, // borl
2945 true, // borlu
2946 true, // bsli
2947 true, // bsliu
2948 true, // bsll
2949 true, // bsllu
2950 true, // bsri
2951 true, // bsriu
2952 true, // bsrl
2953 true, // bsrlu
2954 true, // bxori
2955 true, // bxoriu
2956 true, // bxorl
2957 true, // bxorlu
2958 true, // bzi/fR
2959 true, // bziu/fR
2960 true, // bzl/fR
2961 true, // bzlu/fR
2962 true, // call/retR
2963 true, // canary
2964 true, // close
2965 true, // ctos
2966 true, // disas
2967 true, // divi
2968 true, // diviu
2969 true, // divl
2970 true, // divlu
2971 true, // drop
2972 true, // drop2
2973 true, // drop3
2974 true, // drop4
2975 true, // duc
2976 true, // dup
2977 true, // endhl
2978 true, // endsc
2979 true, // eqi
2980 true, // eqiu
2981 true, // eql
2982 true, // eqlu
2983 true, // eqs
2984 true, // exit
2985 true, // exitvm
2986 true, // flush
2987 true, // fromr
2988 true, // gei
2989 true, // geiu
2990 true, // gel
2991 true, // gelu
2992 true, // ges
2993 true, // getenv
2994 true, // gti
2995 true, // gtiu
2996 true, // gtl
2997 true, // gtlu
2998 true, // gts
2999 true, // indent
3000 true, // iogetb
3001 true, // iosetb
3002 true, // iosize
3003 true, // isa
3004 true, // itoi/nR
3005 true, // itoiu/nR
3006 true, // itol/nR
3007 true, // itolu/nR
3008 true, // iutoi/nR
3009 true, // iutoiu/nR
3010 true, // iutol/nR
3011 true, // iutolu/nR
3012 true, // lei
3013 true, // leiu
3014 true, // lel
3015 true, // lelu
3016 true, // les
3017 true, // lti
3018 true, // ltiu
3019 true, // ltl
3020 true, // ltlu
3021 true, // ltoi/nR
3022 true, // ltoiu/nR
3023 true, // ltol/nR
3024 true, // ltolu/nR
3025 true, // lts
3026 true, // lutoi/nR
3027 true, // lutoiu/nR
3028 true, // lutol/nR
3029 true, // lutolu/nR
3030 true, // map
3031 true, // mgetios
3032 true, // mgetm
3033 true, // mgeto
3034 true, // mgets
3035 true, // mgetsel
3036 true, // mgetsiz
3037 true, // mgetw
3038 true, // mka
3039 true, // mko
3040 true, // mksct
3041 true, // mktya
3042 true, // mktyany
3043 true, // mktyc
3044 true, // mktyi
3045 true, // mktyo
3046 true, // mktys
3047 true, // mktysct
3048 true, // mktyv
3049 true, // mm
3050 true, // modi
3051 true, // modiu
3052 true, // modl
3053 true, // modlu
3054 true, // msetios
3055 true, // msetm
3056 true, // mseto
3057 true, // msets
3058 true, // msetsel
3059 true, // msetsiz
3060 true, // msetw
3061 true, // muli
3062 true, // muliu
3063 true, // mull
3064 true, // mullu
3065 true, // muls
3066 true, // negi
3067 true, // negiu
3068 true, // negl
3069 true, // neglu
3070 true, // nei
3071 true, // neiu
3072 true, // nel
3073 true, // nelu
3074 true, // nes
3075 true, // nip
3076 true, // nip2
3077 true, // nip3
3078 true, // nn
3079 true, // nnn
3080 true, // nop
3081 true, // not
3082 true, // note/nR
3083 true, // nrot
3084 true, // ogetbt
3085 true, // ogetm
3086 true, // ogetu
3087 true, // open
3088 true, // or
3089 true, // osetm
3090 true, // over
3091 true, // pec
3092 true, // peekdi/nR
3093 true, // peekdiu/nR
3094 true, // peekdl/nR
3095 true, // peekdlu/nR
3096 true, // peeki/nR/nR/nR
3097 true, // peekiu/nR/nR
3098 true, // peekl/nR/nR/nR
3099 true, // peeklu/nR/nR
3100 true, // peeks
3101 true, // pokedi/nR
3102 true, // pokediu/nR
3103 true, // pokedl/nR
3104 true, // pokedlu/nR
3105 true, // pokei/nR/nR/nR
3106 true, // pokeiu/nR/nR
3107 true, // pokel/nR/nR/nR
3108 true, // pokelu/nR/nR
3109 true, // pokes
3110 true, // pope
3111 true, // popend
3112 true, // popf/nR
3113 true, // popios
3114 true, // popoac
3115 true, // popob
3116 true, // popobc
3117 true, // popoc
3118 true, // popod
3119 true, // popoi
3120 true, // popom
3121 true, // popoo
3122 true, // popopp
3123 true, // popr/%rR
3124 true, // popvar/nR/nR
3125 true, // powi
3126 true, // powiu
3127 true, // powl
3128 true, // powlu
3129 true, // printi/nR
3130 true, // printiu/nR
3131 true, // printl/nR
3132 true, // printlu/nR
3133 true, // prints
3134 true, // prolog
3135 true, // push/nR
3136 true, // push/lR
3137 true, // push32/nR
3138 true, // push32/lR
3139 true, // pushe/lR
3140 true, // pushend
3141 true, // pushf/nR
3142 true, // pushhi/nR
3143 true, // pushhi/lR
3144 true, // pushios
3145 true, // pushlo/nR
3146 true, // pushlo/lR
3147 true, // pushoac
3148 true, // pushob
3149 true, // pushobc
3150 true, // pushoc
3151 true, // pushod
3152 true, // pushoi
3153 true, // pushom
3154 true, // pushoo
3155 true, // pushopp
3156 true, // pushr/%rR
3157 true, // pushtopvar/nR
3158 true, // pushvar/n0/n0
3159 true, // pushvar/n0/n1
3160 true, // pushvar/n0/n2
3161 true, // pushvar/n0/n3
3162 true, // pushvar/n0/n4
3163 true, // pushvar/n0/n5
3164 true, // pushvar/n0/nR
3165 true, // pushvar/nR/n0
3166 true, // pushvar/nR/n1
3167 true, // pushvar/nR/n2
3168 true, // pushvar/nR/n3
3169 true, // pushvar/nR/n4
3170 true, // pushvar/nR/n5
3171 true, // pushvar/nR/nR
3172 true, // quake
3173 true, // raise
3174 true, // rand
3175 true, // regvar
3176 true, // reloc
3177 true, // restorer/%rR
3178 true, // return
3179 true, // revn/n3
3180 true, // revn/n4
3181 true, // revn/nR
3182 true, // rot
3183 true, // saver/%rR
3184 true, // sconc
3185 true, // sel
3186 true, // setr/%rR
3187 true, // siz
3188 true, // smodi
3189 true, // sref
3190 true, // srefi
3191 true, // srefia
3192 true, // srefio
3193 true, // srefmnt
3194 true, // srefnt
3195 true, // srefo
3196 true, // sset
3197 true, // strace/nR
3198 true, // strref
3199 true, // subi
3200 true, // subiu
3201 true, // subl
3202 true, // sublu
3203 true, // substr
3204 true, // swap
3205 true, // swapgti
3206 true, // swapgtiu
3207 true, // swapgtl
3208 true, // swapgtlu
3209 true, // sync
3210 true, // time
3211 true, // tor
3212 true, // tuck
3213 true, // tyagetb
3214 true, // tyagett
3215 true, // tyisc
3216 true, // tyissct
3217 true, // typof
3218 true, // tysctn
3219 true, // unmap
3220 true, // unreachable
3221 true, // ureloc
3222 true, // write/retR
3223 false, // *ba/fR*-no-fast-branches
3224 false, // *bn/fR*-no-fast-branches
3225 false, // *bnn/fR*-no-fast-branches
3226 false, // *bnzi/fR*-no-fast-branches
3227 false, // *bnziu/fR*-no-fast-branches
3228 false, // *bnzl/fR*-no-fast-branches
3229 false, // *bnzlu/fR*-no-fast-branches
3230 false, // *bzi/fR*-no-fast-branches
3231 false, // *bziu/fR*-no-fast-branches
3232 false, // *bzl/fR*-no-fast-branches
3233 false // *bzlu/fR*-no-fast-branches
3234 };
3235
3236 // FIXME: this is not currently accessed, and in fact may be useless.
3237 const bool
3238 pvm_specialized_instruction_callers [PVM_SPECIALIZED_INSTRUCTION_NO]
3239 = {
3240 false, // !INVALID
3241 false, // !BEGINBASICBLOCK
3242 false, // !EXITVM
3243 false, // !DATALOCATIONS
3244 false, // !NOP
3245 false, // !UNREACHABLE0
3246 false, // !UNREACHABLE1
3247 false, // !UNREACHABLE2
3248 false, // addi
3249 false, // addiu
3250 false, // addl
3251 false, // addlu
3252 false, // ains
3253 false, // and
3254 false, // aref
3255 false, // arefo
3256 false, // arem
3257 false, // aset
3258 false, // asettb
3259 false, // atr
3260 false, // ba/fR
3261 false, // bandi
3262 false, // bandiu
3263 false, // bandl
3264 false, // bandlu
3265 false, // beghl
3266 false, // begsc
3267 false, // bn/fR
3268 false, // bnn/fR
3269 false, // bnoti
3270 false, // bnotiu
3271 false, // bnotl
3272 false, // bnotlu
3273 false, // bnzi/fR
3274 false, // bnziu/fR
3275 false, // bnzl/fR
3276 false, // bnzlu/fR
3277 false, // bori
3278 false, // boriu
3279 false, // borl
3280 false, // borlu
3281 false, // bsli
3282 false, // bsliu
3283 false, // bsll
3284 false, // bsllu
3285 false, // bsri
3286 false, // bsriu
3287 false, // bsrl
3288 false, // bsrlu
3289 false, // bxori
3290 false, // bxoriu
3291 false, // bxorl
3292 false, // bxorlu
3293 false, // bzi/fR
3294 false, // bziu/fR
3295 false, // bzl/fR
3296 false, // bzlu/fR
3297 true, // call/retR
3298 false, // canary
3299 false, // close
3300 false, // ctos
3301 false, // disas
3302 false, // divi
3303 false, // diviu
3304 false, // divl
3305 false, // divlu
3306 false, // drop
3307 false, // drop2
3308 false, // drop3
3309 false, // drop4
3310 false, // duc
3311 false, // dup
3312 false, // endhl
3313 false, // endsc
3314 false, // eqi
3315 false, // eqiu
3316 false, // eql
3317 false, // eqlu
3318 false, // eqs
3319 false, // exit
3320 false, // exitvm
3321 false, // flush
3322 false, // fromr
3323 false, // gei
3324 false, // geiu
3325 false, // gel
3326 false, // gelu
3327 false, // ges
3328 false, // getenv
3329 false, // gti
3330 false, // gtiu
3331 false, // gtl
3332 false, // gtlu
3333 false, // gts
3334 false, // indent
3335 false, // iogetb
3336 false, // iosetb
3337 false, // iosize
3338 false, // isa
3339 false, // itoi/nR
3340 false, // itoiu/nR
3341 false, // itol/nR
3342 false, // itolu/nR
3343 false, // iutoi/nR
3344 false, // iutoiu/nR
3345 false, // iutol/nR
3346 false, // iutolu/nR
3347 false, // lei
3348 false, // leiu
3349 false, // lel
3350 false, // lelu
3351 false, // les
3352 false, // lti
3353 false, // ltiu
3354 false, // ltl
3355 false, // ltlu
3356 false, // ltoi/nR
3357 false, // ltoiu/nR
3358 false, // ltol/nR
3359 false, // ltolu/nR
3360 false, // lts
3361 false, // lutoi/nR
3362 false, // lutoiu/nR
3363 false, // lutol/nR
3364 false, // lutolu/nR
3365 false, // map
3366 false, // mgetios
3367 false, // mgetm
3368 false, // mgeto
3369 false, // mgets
3370 false, // mgetsel
3371 false, // mgetsiz
3372 false, // mgetw
3373 false, // mka
3374 false, // mko
3375 false, // mksct
3376 false, // mktya
3377 false, // mktyany
3378 false, // mktyc
3379 false, // mktyi
3380 false, // mktyo
3381 false, // mktys
3382 false, // mktysct
3383 false, // mktyv
3384 false, // mm
3385 false, // modi
3386 false, // modiu
3387 false, // modl
3388 false, // modlu
3389 false, // msetios
3390 false, // msetm
3391 false, // mseto
3392 false, // msets
3393 false, // msetsel
3394 false, // msetsiz
3395 false, // msetw
3396 false, // muli
3397 false, // muliu
3398 false, // mull
3399 false, // mullu
3400 false, // muls
3401 false, // negi
3402 false, // negiu
3403 false, // negl
3404 false, // neglu
3405 false, // nei
3406 false, // neiu
3407 false, // nel
3408 false, // nelu
3409 false, // nes
3410 false, // nip
3411 false, // nip2
3412 false, // nip3
3413 false, // nn
3414 false, // nnn
3415 false, // nop
3416 false, // not
3417 false, // note/nR
3418 false, // nrot
3419 false, // ogetbt
3420 false, // ogetm
3421 false, // ogetu
3422 false, // open
3423 false, // or
3424 false, // osetm
3425 false, // over
3426 false, // pec
3427 false, // peekdi/nR
3428 false, // peekdiu/nR
3429 false, // peekdl/nR
3430 false, // peekdlu/nR
3431 false, // peeki/nR/nR/nR
3432 false, // peekiu/nR/nR
3433 false, // peekl/nR/nR/nR
3434 false, // peeklu/nR/nR
3435 false, // peeks
3436 false, // pokedi/nR
3437 false, // pokediu/nR
3438 false, // pokedl/nR
3439 false, // pokedlu/nR
3440 false, // pokei/nR/nR/nR
3441 false, // pokeiu/nR/nR
3442 false, // pokel/nR/nR/nR
3443 false, // pokelu/nR/nR
3444 false, // pokes
3445 false, // pope
3446 false, // popend
3447 false, // popf/nR
3448 false, // popios
3449 false, // popoac
3450 false, // popob
3451 false, // popobc
3452 false, // popoc
3453 false, // popod
3454 false, // popoi
3455 false, // popom
3456 false, // popoo
3457 false, // popopp
3458 false, // popr/%rR
3459 false, // popvar/nR/nR
3460 false, // powi
3461 false, // powiu
3462 false, // powl
3463 false, // powlu
3464 false, // printi/nR
3465 false, // printiu/nR
3466 false, // printl/nR
3467 false, // printlu/nR
3468 false, // prints
3469 false, // prolog
3470 false, // push/nR
3471 false, // push/lR
3472 false, // push32/nR
3473 false, // push32/lR
3474 false, // pushe/lR
3475 false, // pushend
3476 false, // pushf/nR
3477 false, // pushhi/nR
3478 false, // pushhi/lR
3479 false, // pushios
3480 false, // pushlo/nR
3481 false, // pushlo/lR
3482 false, // pushoac
3483 false, // pushob
3484 false, // pushobc
3485 false, // pushoc
3486 false, // pushod
3487 false, // pushoi
3488 false, // pushom
3489 false, // pushoo
3490 false, // pushopp
3491 false, // pushr/%rR
3492 false, // pushtopvar/nR
3493 false, // pushvar/n0/n0
3494 false, // pushvar/n0/n1
3495 false, // pushvar/n0/n2
3496 false, // pushvar/n0/n3
3497 false, // pushvar/n0/n4
3498 false, // pushvar/n0/n5
3499 false, // pushvar/n0/nR
3500 false, // pushvar/nR/n0
3501 false, // pushvar/nR/n1
3502 false, // pushvar/nR/n2
3503 false, // pushvar/nR/n3
3504 false, // pushvar/nR/n4
3505 false, // pushvar/nR/n5
3506 false, // pushvar/nR/nR
3507 false, // quake
3508 false, // raise
3509 false, // rand
3510 false, // regvar
3511 false, // reloc
3512 false, // restorer/%rR
3513 false, // return
3514 false, // revn/n3
3515 false, // revn/n4
3516 false, // revn/nR
3517 false, // rot
3518 false, // saver/%rR
3519 false, // sconc
3520 false, // sel
3521 false, // setr/%rR
3522 false, // siz
3523 false, // smodi
3524 false, // sref
3525 false, // srefi
3526 false, // srefia
3527 false, // srefio
3528 false, // srefmnt
3529 false, // srefnt
3530 false, // srefo
3531 false, // sset
3532 false, // strace/nR
3533 false, // strref
3534 false, // subi
3535 false, // subiu
3536 false, // subl
3537 false, // sublu
3538 false, // substr
3539 false, // swap
3540 false, // swapgti
3541 false, // swapgtiu
3542 false, // swapgtl
3543 false, // swapgtlu
3544 false, // sync
3545 false, // time
3546 false, // tor
3547 false, // tuck
3548 false, // tyagetb
3549 false, // tyagett
3550 false, // tyisc
3551 false, // tyissct
3552 false, // typof
3553 false, // tysctn
3554 false, // unmap
3555 false, // unreachable
3556 false, // ureloc
3557 true, // write/retR
3558 false, // *ba/fR*-no-fast-branches
3559 false, // *bn/fR*-no-fast-branches
3560 false, // *bnn/fR*-no-fast-branches
3561 false, // *bnzi/fR*-no-fast-branches
3562 false, // *bnziu/fR*-no-fast-branches
3563 false, // *bnzl/fR*-no-fast-branches
3564 false, // *bnzlu/fR*-no-fast-branches
3565 false, // *bzi/fR*-no-fast-branches
3566 false, // *bziu/fR*-no-fast-branches
3567 false, // *bzl/fR*-no-fast-branches
3568 false // *bzlu/fR*-no-fast-branches
3569 };
3570
3571 // FIXME: this is not currently accessed, and in fact may be useless.
3572 const bool
3573 pvm_specialized_instruction_callees [PVM_SPECIALIZED_INSTRUCTION_NO]
3574 = {
3575 false, // !INVALID
3576 false, // !BEGINBASICBLOCK
3577 false, // !EXITVM
3578 false, // !DATALOCATIONS
3579 false, // !NOP
3580 false, // !UNREACHABLE0
3581 false, // !UNREACHABLE1
3582 false, // !UNREACHABLE2
3583 false, // addi
3584 false, // addiu
3585 false, // addl
3586 false, // addlu
3587 false, // ains
3588 false, // and
3589 false, // aref
3590 false, // arefo
3591 false, // arem
3592 false, // aset
3593 false, // asettb
3594 false, // atr
3595 false, // ba/fR
3596 false, // bandi
3597 false, // bandiu
3598 false, // bandl
3599 false, // bandlu
3600 false, // beghl
3601 false, // begsc
3602 false, // bn/fR
3603 false, // bnn/fR
3604 false, // bnoti
3605 false, // bnotiu
3606 false, // bnotl
3607 false, // bnotlu
3608 false, // bnzi/fR
3609 false, // bnziu/fR
3610 false, // bnzl/fR
3611 false, // bnzlu/fR
3612 false, // bori
3613 false, // boriu
3614 false, // borl
3615 false, // borlu
3616 false, // bsli
3617 false, // bsliu
3618 false, // bsll
3619 false, // bsllu
3620 false, // bsri
3621 false, // bsriu
3622 false, // bsrl
3623 false, // bsrlu
3624 false, // bxori
3625 false, // bxoriu
3626 false, // bxorl
3627 false, // bxorlu
3628 false, // bzi/fR
3629 false, // bziu/fR
3630 false, // bzl/fR
3631 false, // bzlu/fR
3632 false, // call/retR
3633 false, // canary
3634 false, // close
3635 false, // ctos
3636 false, // disas
3637 false, // divi
3638 false, // diviu
3639 false, // divl
3640 false, // divlu
3641 false, // drop
3642 false, // drop2
3643 false, // drop3
3644 false, // drop4
3645 false, // duc
3646 false, // dup
3647 false, // endhl
3648 false, // endsc
3649 false, // eqi
3650 false, // eqiu
3651 false, // eql
3652 false, // eqlu
3653 false, // eqs
3654 false, // exit
3655 false, // exitvm
3656 false, // flush
3657 false, // fromr
3658 false, // gei
3659 false, // geiu
3660 false, // gel
3661 false, // gelu
3662 false, // ges
3663 false, // getenv
3664 false, // gti
3665 false, // gtiu
3666 false, // gtl
3667 false, // gtlu
3668 false, // gts
3669 false, // indent
3670 false, // iogetb
3671 false, // iosetb
3672 false, // iosize
3673 false, // isa
3674 false, // itoi/nR
3675 false, // itoiu/nR
3676 false, // itol/nR
3677 false, // itolu/nR
3678 false, // iutoi/nR
3679 false, // iutoiu/nR
3680 false, // iutol/nR
3681 false, // iutolu/nR
3682 false, // lei
3683 false, // leiu
3684 false, // lel
3685 false, // lelu
3686 false, // les
3687 false, // lti
3688 false, // ltiu
3689 false, // ltl
3690 false, // ltlu
3691 false, // ltoi/nR
3692 false, // ltoiu/nR
3693 false, // ltol/nR
3694 false, // ltolu/nR
3695 false, // lts
3696 false, // lutoi/nR
3697 false, // lutoiu/nR
3698 false, // lutol/nR
3699 false, // lutolu/nR
3700 false, // map
3701 false, // mgetios
3702 false, // mgetm
3703 false, // mgeto
3704 false, // mgets
3705 false, // mgetsel
3706 false, // mgetsiz
3707 false, // mgetw
3708 false, // mka
3709 false, // mko
3710 false, // mksct
3711 false, // mktya
3712 false, // mktyany
3713 false, // mktyc
3714 false, // mktyi
3715 false, // mktyo
3716 false, // mktys
3717 false, // mktysct
3718 false, // mktyv
3719 false, // mm
3720 false, // modi
3721 false, // modiu
3722 false, // modl
3723 false, // modlu
3724 false, // msetios
3725 false, // msetm
3726 false, // mseto
3727 false, // msets
3728 false, // msetsel
3729 false, // msetsiz
3730 false, // msetw
3731 false, // muli
3732 false, // muliu
3733 false, // mull
3734 false, // mullu
3735 false, // muls
3736 false, // negi
3737 false, // negiu
3738 false, // negl
3739 false, // neglu
3740 false, // nei
3741 false, // neiu
3742 false, // nel
3743 false, // nelu
3744 false, // nes
3745 false, // nip
3746 false, // nip2
3747 false, // nip3
3748 false, // nn
3749 false, // nnn
3750 false, // nop
3751 false, // not
3752 false, // note/nR
3753 false, // nrot
3754 false, // ogetbt
3755 false, // ogetm
3756 false, // ogetu
3757 false, // open
3758 false, // or
3759 false, // osetm
3760 false, // over
3761 false, // pec
3762 false, // peekdi/nR
3763 false, // peekdiu/nR
3764 false, // peekdl/nR
3765 false, // peekdlu/nR
3766 false, // peeki/nR/nR/nR
3767 false, // peekiu/nR/nR
3768 false, // peekl/nR/nR/nR
3769 false, // peeklu/nR/nR
3770 false, // peeks
3771 false, // pokedi/nR
3772 false, // pokediu/nR
3773 false, // pokedl/nR
3774 false, // pokedlu/nR
3775 false, // pokei/nR/nR/nR
3776 false, // pokeiu/nR/nR
3777 false, // pokel/nR/nR/nR
3778 false, // pokelu/nR/nR
3779 false, // pokes
3780 false, // pope
3781 false, // popend
3782 false, // popf/nR
3783 false, // popios
3784 false, // popoac
3785 false, // popob
3786 false, // popobc
3787 false, // popoc
3788 false, // popod
3789 false, // popoi
3790 false, // popom
3791 false, // popoo
3792 false, // popopp
3793 false, // popr/%rR
3794 false, // popvar/nR/nR
3795 false, // powi
3796 false, // powiu
3797 false, // powl
3798 false, // powlu
3799 false, // printi/nR
3800 false, // printiu/nR
3801 false, // printl/nR
3802 false, // printlu/nR
3803 false, // prints
3804 true, // prolog
3805 false, // push/nR
3806 false, // push/lR
3807 false, // push32/nR
3808 false, // push32/lR
3809 false, // pushe/lR
3810 false, // pushend
3811 false, // pushf/nR
3812 false, // pushhi/nR
3813 false, // pushhi/lR
3814 false, // pushios
3815 false, // pushlo/nR
3816 false, // pushlo/lR
3817 false, // pushoac
3818 false, // pushob
3819 false, // pushobc
3820 false, // pushoc
3821 false, // pushod
3822 false, // pushoi
3823 false, // pushom
3824 false, // pushoo
3825 false, // pushopp
3826 false, // pushr/%rR
3827 false, // pushtopvar/nR
3828 false, // pushvar/n0/n0
3829 false, // pushvar/n0/n1
3830 false, // pushvar/n0/n2
3831 false, // pushvar/n0/n3
3832 false, // pushvar/n0/n4
3833 false, // pushvar/n0/n5
3834 false, // pushvar/n0/nR
3835 false, // pushvar/nR/n0
3836 false, // pushvar/nR/n1
3837 false, // pushvar/nR/n2
3838 false, // pushvar/nR/n3
3839 false, // pushvar/nR/n4
3840 false, // pushvar/nR/n5
3841 false, // pushvar/nR/nR
3842 false, // quake
3843 false, // raise
3844 false, // rand
3845 false, // regvar
3846 false, // reloc
3847 false, // restorer/%rR
3848 false, // return
3849 false, // revn/n3
3850 false, // revn/n4
3851 false, // revn/nR
3852 false, // rot
3853 false, // saver/%rR
3854 false, // sconc
3855 false, // sel
3856 false, // setr/%rR
3857 false, // siz
3858 false, // smodi
3859 false, // sref
3860 false, // srefi
3861 false, // srefia
3862 false, // srefio
3863 false, // srefmnt
3864 false, // srefnt
3865 false, // srefo
3866 false, // sset
3867 false, // strace/nR
3868 false, // strref
3869 false, // subi
3870 false, // subiu
3871 false, // subl
3872 false, // sublu
3873 false, // substr
3874 false, // swap
3875 false, // swapgti
3876 false, // swapgtiu
3877 false, // swapgtl
3878 false, // swapgtlu
3879 false, // sync
3880 false, // time
3881 false, // tor
3882 false, // tuck
3883 false, // tyagetb
3884 false, // tyagett
3885 false, // tyisc
3886 false, // tyissct
3887 false, // typof
3888 false, // tysctn
3889 false, // unmap
3890 false, // unreachable
3891 false, // ureloc
3892 false, // write/retR
3893 false, // *ba/fR*-no-fast-branches
3894 false, // *bn/fR*-no-fast-branches
3895 false, // *bnn/fR*-no-fast-branches
3896 false, // *bnzi/fR*-no-fast-branches
3897 false, // *bnziu/fR*-no-fast-branches
3898 false, // *bnzl/fR*-no-fast-branches
3899 false, // *bnzlu/fR*-no-fast-branches
3900 false, // *bzi/fR*-no-fast-branches
3901 false, // *bziu/fR*-no-fast-branches
3902 false, // *bzl/fR*-no-fast-branches
3903 false // *bzlu/fR*-no-fast-branches
3904 };
3905
3906 /* An array whose indices are specialised instruction opcodes, and
3907 whose elements are the corresponding unspecialised instructions
3908 opcodes -- or -1 when there is no mapping mapping having */
3909 const int
3910 pvm_specialized_instruction_to_unspecialized_instruction
3911 [PVM_SPECIALIZED_INSTRUCTION_NO]
3912 = {
3913 -1, /* !INVALID */
3914 -1, /* !BEGINBASICBLOCK */
3915 -1, /* !EXITVM */
3916 -1, /* !DATALOCATIONS */
3917 -1, /* !NOP */
3918 -1, /* !UNREACHABLE0 */
3919 -1, /* !UNREACHABLE1 */
3920 -1, /* !UNREACHABLE2 */
3921 pvm_meta_instruction_id_addi, /* addi */
3922 pvm_meta_instruction_id_addiu, /* addiu */
3923 pvm_meta_instruction_id_addl, /* addl */
3924 pvm_meta_instruction_id_addlu, /* addlu */
3925 pvm_meta_instruction_id_ains, /* ains */
3926 pvm_meta_instruction_id_and, /* and */
3927 pvm_meta_instruction_id_aref, /* aref */
3928 pvm_meta_instruction_id_arefo, /* arefo */
3929 pvm_meta_instruction_id_arem, /* arem */
3930 pvm_meta_instruction_id_aset, /* aset */
3931 pvm_meta_instruction_id_asettb, /* asettb */
3932 pvm_meta_instruction_id_atr, /* atr */
3933 pvm_meta_instruction_id_ba, /* ba/fR */
3934 pvm_meta_instruction_id_bandi, /* bandi */
3935 pvm_meta_instruction_id_bandiu, /* bandiu */
3936 pvm_meta_instruction_id_bandl, /* bandl */
3937 pvm_meta_instruction_id_bandlu, /* bandlu */
3938 pvm_meta_instruction_id_beghl, /* beghl */
3939 pvm_meta_instruction_id_begsc, /* begsc */
3940 pvm_meta_instruction_id_bn, /* bn/fR */
3941 pvm_meta_instruction_id_bnn, /* bnn/fR */
3942 pvm_meta_instruction_id_bnoti, /* bnoti */
3943 pvm_meta_instruction_id_bnotiu, /* bnotiu */
3944 pvm_meta_instruction_id_bnotl, /* bnotl */
3945 pvm_meta_instruction_id_bnotlu, /* bnotlu */
3946 pvm_meta_instruction_id_bnzi, /* bnzi/fR */
3947 pvm_meta_instruction_id_bnziu, /* bnziu/fR */
3948 pvm_meta_instruction_id_bnzl, /* bnzl/fR */
3949 pvm_meta_instruction_id_bnzlu, /* bnzlu/fR */
3950 pvm_meta_instruction_id_bori, /* bori */
3951 pvm_meta_instruction_id_boriu, /* boriu */
3952 pvm_meta_instruction_id_borl, /* borl */
3953 pvm_meta_instruction_id_borlu, /* borlu */
3954 pvm_meta_instruction_id_bsli, /* bsli */
3955 pvm_meta_instruction_id_bsliu, /* bsliu */
3956 pvm_meta_instruction_id_bsll, /* bsll */
3957 pvm_meta_instruction_id_bsllu, /* bsllu */
3958 pvm_meta_instruction_id_bsri, /* bsri */
3959 pvm_meta_instruction_id_bsriu, /* bsriu */
3960 pvm_meta_instruction_id_bsrl, /* bsrl */
3961 pvm_meta_instruction_id_bsrlu, /* bsrlu */
3962 pvm_meta_instruction_id_bxori, /* bxori */
3963 pvm_meta_instruction_id_bxoriu, /* bxoriu */
3964 pvm_meta_instruction_id_bxorl, /* bxorl */
3965 pvm_meta_instruction_id_bxorlu, /* bxorlu */
3966 pvm_meta_instruction_id_bzi, /* bzi/fR */
3967 pvm_meta_instruction_id_bziu, /* bziu/fR */
3968 pvm_meta_instruction_id_bzl, /* bzl/fR */
3969 pvm_meta_instruction_id_bzlu, /* bzlu/fR */
3970 pvm_meta_instruction_id_call, /* call/retR */
3971 pvm_meta_instruction_id_canary, /* canary */
3972 pvm_meta_instruction_id_close, /* close */
3973 pvm_meta_instruction_id_ctos, /* ctos */
3974 pvm_meta_instruction_id_disas, /* disas */
3975 pvm_meta_instruction_id_divi, /* divi */
3976 pvm_meta_instruction_id_diviu, /* diviu */
3977 pvm_meta_instruction_id_divl, /* divl */
3978 pvm_meta_instruction_id_divlu, /* divlu */
3979 pvm_meta_instruction_id_drop, /* drop */
3980 pvm_meta_instruction_id_drop2, /* drop2 */
3981 pvm_meta_instruction_id_drop3, /* drop3 */
3982 pvm_meta_instruction_id_drop4, /* drop4 */
3983 pvm_meta_instruction_id_duc, /* duc */
3984 pvm_meta_instruction_id_dup, /* dup */
3985 pvm_meta_instruction_id_endhl, /* endhl */
3986 pvm_meta_instruction_id_endsc, /* endsc */
3987 pvm_meta_instruction_id_eqi, /* eqi */
3988 pvm_meta_instruction_id_eqiu, /* eqiu */
3989 pvm_meta_instruction_id_eql, /* eql */
3990 pvm_meta_instruction_id_eqlu, /* eqlu */
3991 pvm_meta_instruction_id_eqs, /* eqs */
3992 pvm_meta_instruction_id_exit, /* exit */
3993 pvm_meta_instruction_id_exitvm, /* exitvm */
3994 pvm_meta_instruction_id_flush, /* flush */
3995 pvm_meta_instruction_id_fromr, /* fromr */
3996 pvm_meta_instruction_id_gei, /* gei */
3997 pvm_meta_instruction_id_geiu, /* geiu */
3998 pvm_meta_instruction_id_gel, /* gel */
3999 pvm_meta_instruction_id_gelu, /* gelu */
4000 pvm_meta_instruction_id_ges, /* ges */
4001 pvm_meta_instruction_id_getenv, /* getenv */
4002 pvm_meta_instruction_id_gti, /* gti */
4003 pvm_meta_instruction_id_gtiu, /* gtiu */
4004 pvm_meta_instruction_id_gtl, /* gtl */
4005 pvm_meta_instruction_id_gtlu, /* gtlu */
4006 pvm_meta_instruction_id_gts, /* gts */
4007 pvm_meta_instruction_id_indent, /* indent */
4008 pvm_meta_instruction_id_iogetb, /* iogetb */
4009 pvm_meta_instruction_id_iosetb, /* iosetb */
4010 pvm_meta_instruction_id_iosize, /* iosize */
4011 pvm_meta_instruction_id_isa, /* isa */
4012 pvm_meta_instruction_id_itoi, /* itoi/nR */
4013 pvm_meta_instruction_id_itoiu, /* itoiu/nR */
4014 pvm_meta_instruction_id_itol, /* itol/nR */
4015 pvm_meta_instruction_id_itolu, /* itolu/nR */
4016 pvm_meta_instruction_id_iutoi, /* iutoi/nR */
4017 pvm_meta_instruction_id_iutoiu, /* iutoiu/nR */
4018 pvm_meta_instruction_id_iutol, /* iutol/nR */
4019 pvm_meta_instruction_id_iutolu, /* iutolu/nR */
4020 pvm_meta_instruction_id_lei, /* lei */
4021 pvm_meta_instruction_id_leiu, /* leiu */
4022 pvm_meta_instruction_id_lel, /* lel */
4023 pvm_meta_instruction_id_lelu, /* lelu */
4024 pvm_meta_instruction_id_les, /* les */
4025 pvm_meta_instruction_id_lti, /* lti */
4026 pvm_meta_instruction_id_ltiu, /* ltiu */
4027 pvm_meta_instruction_id_ltl, /* ltl */
4028 pvm_meta_instruction_id_ltlu, /* ltlu */
4029 pvm_meta_instruction_id_ltoi, /* ltoi/nR */
4030 pvm_meta_instruction_id_ltoiu, /* ltoiu/nR */
4031 pvm_meta_instruction_id_ltol, /* ltol/nR */
4032 pvm_meta_instruction_id_ltolu, /* ltolu/nR */
4033 pvm_meta_instruction_id_lts, /* lts */
4034 pvm_meta_instruction_id_lutoi, /* lutoi/nR */
4035 pvm_meta_instruction_id_lutoiu, /* lutoiu/nR */
4036 pvm_meta_instruction_id_lutol, /* lutol/nR */
4037 pvm_meta_instruction_id_lutolu, /* lutolu/nR */
4038 pvm_meta_instruction_id_map, /* map */
4039 pvm_meta_instruction_id_mgetios, /* mgetios */
4040 pvm_meta_instruction_id_mgetm, /* mgetm */
4041 pvm_meta_instruction_id_mgeto, /* mgeto */
4042 pvm_meta_instruction_id_mgets, /* mgets */
4043 pvm_meta_instruction_id_mgetsel, /* mgetsel */
4044 pvm_meta_instruction_id_mgetsiz, /* mgetsiz */
4045 pvm_meta_instruction_id_mgetw, /* mgetw */
4046 pvm_meta_instruction_id_mka, /* mka */
4047 pvm_meta_instruction_id_mko, /* mko */
4048 pvm_meta_instruction_id_mksct, /* mksct */
4049 pvm_meta_instruction_id_mktya, /* mktya */
4050 pvm_meta_instruction_id_mktyany, /* mktyany */
4051 pvm_meta_instruction_id_mktyc, /* mktyc */
4052 pvm_meta_instruction_id_mktyi, /* mktyi */
4053 pvm_meta_instruction_id_mktyo, /* mktyo */
4054 pvm_meta_instruction_id_mktys, /* mktys */
4055 pvm_meta_instruction_id_mktysct, /* mktysct */
4056 pvm_meta_instruction_id_mktyv, /* mktyv */
4057 pvm_meta_instruction_id_mm, /* mm */
4058 pvm_meta_instruction_id_modi, /* modi */
4059 pvm_meta_instruction_id_modiu, /* modiu */
4060 pvm_meta_instruction_id_modl, /* modl */
4061 pvm_meta_instruction_id_modlu, /* modlu */
4062 pvm_meta_instruction_id_msetios, /* msetios */
4063 pvm_meta_instruction_id_msetm, /* msetm */
4064 pvm_meta_instruction_id_mseto, /* mseto */
4065 pvm_meta_instruction_id_msets, /* msets */
4066 pvm_meta_instruction_id_msetsel, /* msetsel */
4067 pvm_meta_instruction_id_msetsiz, /* msetsiz */
4068 pvm_meta_instruction_id_msetw, /* msetw */
4069 pvm_meta_instruction_id_muli, /* muli */
4070 pvm_meta_instruction_id_muliu, /* muliu */
4071 pvm_meta_instruction_id_mull, /* mull */
4072 pvm_meta_instruction_id_mullu, /* mullu */
4073 pvm_meta_instruction_id_muls, /* muls */
4074 pvm_meta_instruction_id_negi, /* negi */
4075 pvm_meta_instruction_id_negiu, /* negiu */
4076 pvm_meta_instruction_id_negl, /* negl */
4077 pvm_meta_instruction_id_neglu, /* neglu */
4078 pvm_meta_instruction_id_nei, /* nei */
4079 pvm_meta_instruction_id_neiu, /* neiu */
4080 pvm_meta_instruction_id_nel, /* nel */
4081 pvm_meta_instruction_id_nelu, /* nelu */
4082 pvm_meta_instruction_id_nes, /* nes */
4083 pvm_meta_instruction_id_nip, /* nip */
4084 pvm_meta_instruction_id_nip2, /* nip2 */
4085 pvm_meta_instruction_id_nip3, /* nip3 */
4086 pvm_meta_instruction_id_nn, /* nn */
4087 pvm_meta_instruction_id_nnn, /* nnn */
4088 pvm_meta_instruction_id_nop, /* nop */
4089 pvm_meta_instruction_id_not, /* not */
4090 pvm_meta_instruction_id_note, /* note/nR */
4091 pvm_meta_instruction_id_nrot, /* nrot */
4092 pvm_meta_instruction_id_ogetbt, /* ogetbt */
4093 pvm_meta_instruction_id_ogetm, /* ogetm */
4094 pvm_meta_instruction_id_ogetu, /* ogetu */
4095 pvm_meta_instruction_id_open, /* open */
4096 pvm_meta_instruction_id_or, /* or */
4097 pvm_meta_instruction_id_osetm, /* osetm */
4098 pvm_meta_instruction_id_over, /* over */
4099 pvm_meta_instruction_id_pec, /* pec */
4100 pvm_meta_instruction_id_peekdi, /* peekdi/nR */
4101 pvm_meta_instruction_id_peekdiu, /* peekdiu/nR */
4102 pvm_meta_instruction_id_peekdl, /* peekdl/nR */
4103 pvm_meta_instruction_id_peekdlu, /* peekdlu/nR */
4104 pvm_meta_instruction_id_peeki, /* peeki/nR/nR/nR */
4105 pvm_meta_instruction_id_peekiu, /* peekiu/nR/nR */
4106 pvm_meta_instruction_id_peekl, /* peekl/nR/nR/nR */
4107 pvm_meta_instruction_id_peeklu, /* peeklu/nR/nR */
4108 pvm_meta_instruction_id_peeks, /* peeks */
4109 pvm_meta_instruction_id_pokedi, /* pokedi/nR */
4110 pvm_meta_instruction_id_pokediu, /* pokediu/nR */
4111 pvm_meta_instruction_id_pokedl, /* pokedl/nR */
4112 pvm_meta_instruction_id_pokedlu, /* pokedlu/nR */
4113 pvm_meta_instruction_id_pokei, /* pokei/nR/nR/nR */
4114 pvm_meta_instruction_id_pokeiu, /* pokeiu/nR/nR */
4115 pvm_meta_instruction_id_pokel, /* pokel/nR/nR/nR */
4116 pvm_meta_instruction_id_pokelu, /* pokelu/nR/nR */
4117 pvm_meta_instruction_id_pokes, /* pokes */
4118 pvm_meta_instruction_id_pope, /* pope */
4119 pvm_meta_instruction_id_popend, /* popend */
4120 pvm_meta_instruction_id_popf, /* popf/nR */
4121 pvm_meta_instruction_id_popios, /* popios */
4122 pvm_meta_instruction_id_popoac, /* popoac */
4123 pvm_meta_instruction_id_popob, /* popob */
4124 pvm_meta_instruction_id_popobc, /* popobc */
4125 pvm_meta_instruction_id_popoc, /* popoc */
4126 pvm_meta_instruction_id_popod, /* popod */
4127 pvm_meta_instruction_id_popoi, /* popoi */
4128 pvm_meta_instruction_id_popom, /* popom */
4129 pvm_meta_instruction_id_popoo, /* popoo */
4130 pvm_meta_instruction_id_popopp, /* popopp */
4131 pvm_meta_instruction_id_popr, /* popr/%rR */
4132 pvm_meta_instruction_id_popvar, /* popvar/nR/nR */
4133 pvm_meta_instruction_id_powi, /* powi */
4134 pvm_meta_instruction_id_powiu, /* powiu */
4135 pvm_meta_instruction_id_powl, /* powl */
4136 pvm_meta_instruction_id_powlu, /* powlu */
4137 pvm_meta_instruction_id_printi, /* printi/nR */
4138 pvm_meta_instruction_id_printiu, /* printiu/nR */
4139 pvm_meta_instruction_id_printl, /* printl/nR */
4140 pvm_meta_instruction_id_printlu, /* printlu/nR */
4141 pvm_meta_instruction_id_prints, /* prints */
4142 pvm_meta_instruction_id_prolog, /* prolog */
4143 pvm_meta_instruction_id_push, /* push/nR */
4144 pvm_meta_instruction_id_push, /* push/lR */
4145 pvm_meta_instruction_id_push32, /* push32/nR */
4146 pvm_meta_instruction_id_push32, /* push32/lR */
4147 pvm_meta_instruction_id_pushe, /* pushe/lR */
4148 pvm_meta_instruction_id_pushend, /* pushend */
4149 pvm_meta_instruction_id_pushf, /* pushf/nR */
4150 pvm_meta_instruction_id_pushhi, /* pushhi/nR */
4151 pvm_meta_instruction_id_pushhi, /* pushhi/lR */
4152 pvm_meta_instruction_id_pushios, /* pushios */
4153 pvm_meta_instruction_id_pushlo, /* pushlo/nR */
4154 pvm_meta_instruction_id_pushlo, /* pushlo/lR */
4155 pvm_meta_instruction_id_pushoac, /* pushoac */
4156 pvm_meta_instruction_id_pushob, /* pushob */
4157 pvm_meta_instruction_id_pushobc, /* pushobc */
4158 pvm_meta_instruction_id_pushoc, /* pushoc */
4159 pvm_meta_instruction_id_pushod, /* pushod */
4160 pvm_meta_instruction_id_pushoi, /* pushoi */
4161 pvm_meta_instruction_id_pushom, /* pushom */
4162 pvm_meta_instruction_id_pushoo, /* pushoo */
4163 pvm_meta_instruction_id_pushopp, /* pushopp */
4164 pvm_meta_instruction_id_pushr, /* pushr/%rR */
4165 pvm_meta_instruction_id_pushtopvar, /* pushtopvar/nR */
4166 pvm_meta_instruction_id_pushvar, /* pushvar/n0/n0 */
4167 pvm_meta_instruction_id_pushvar, /* pushvar/n0/n1 */
4168 pvm_meta_instruction_id_pushvar, /* pushvar/n0/n2 */
4169 pvm_meta_instruction_id_pushvar, /* pushvar/n0/n3 */
4170 pvm_meta_instruction_id_pushvar, /* pushvar/n0/n4 */
4171 pvm_meta_instruction_id_pushvar, /* pushvar/n0/n5 */
4172 pvm_meta_instruction_id_pushvar, /* pushvar/n0/nR */
4173 pvm_meta_instruction_id_pushvar, /* pushvar/nR/n0 */
4174 pvm_meta_instruction_id_pushvar, /* pushvar/nR/n1 */
4175 pvm_meta_instruction_id_pushvar, /* pushvar/nR/n2 */
4176 pvm_meta_instruction_id_pushvar, /* pushvar/nR/n3 */
4177 pvm_meta_instruction_id_pushvar, /* pushvar/nR/n4 */
4178 pvm_meta_instruction_id_pushvar, /* pushvar/nR/n5 */
4179 pvm_meta_instruction_id_pushvar, /* pushvar/nR/nR */
4180 pvm_meta_instruction_id_quake, /* quake */
4181 pvm_meta_instruction_id_raise, /* raise */
4182 pvm_meta_instruction_id_rand, /* rand */
4183 pvm_meta_instruction_id_regvar, /* regvar */
4184 pvm_meta_instruction_id_reloc, /* reloc */
4185 pvm_meta_instruction_id_restorer, /* restorer/%rR */
4186 pvm_meta_instruction_id_return, /* return */
4187 pvm_meta_instruction_id_revn, /* revn/n3 */
4188 pvm_meta_instruction_id_revn, /* revn/n4 */
4189 pvm_meta_instruction_id_revn, /* revn/nR */
4190 pvm_meta_instruction_id_rot, /* rot */
4191 pvm_meta_instruction_id_saver, /* saver/%rR */
4192 pvm_meta_instruction_id_sconc, /* sconc */
4193 pvm_meta_instruction_id_sel, /* sel */
4194 pvm_meta_instruction_id_setr, /* setr/%rR */
4195 pvm_meta_instruction_id_siz, /* siz */
4196 pvm_meta_instruction_id_smodi, /* smodi */
4197 pvm_meta_instruction_id_sref, /* sref */
4198 pvm_meta_instruction_id_srefi, /* srefi */
4199 pvm_meta_instruction_id_srefia, /* srefia */
4200 pvm_meta_instruction_id_srefio, /* srefio */
4201 pvm_meta_instruction_id_srefmnt, /* srefmnt */
4202 pvm_meta_instruction_id_srefnt, /* srefnt */
4203 pvm_meta_instruction_id_srefo, /* srefo */
4204 pvm_meta_instruction_id_sset, /* sset */
4205 pvm_meta_instruction_id_strace, /* strace/nR */
4206 pvm_meta_instruction_id_strref, /* strref */
4207 pvm_meta_instruction_id_subi, /* subi */
4208 pvm_meta_instruction_id_subiu, /* subiu */
4209 pvm_meta_instruction_id_subl, /* subl */
4210 pvm_meta_instruction_id_sublu, /* sublu */
4211 pvm_meta_instruction_id_substr, /* substr */
4212 pvm_meta_instruction_id_swap, /* swap */
4213 pvm_meta_instruction_id_swapgti, /* swapgti */
4214 pvm_meta_instruction_id_swapgtiu, /* swapgtiu */
4215 pvm_meta_instruction_id_swapgtl, /* swapgtl */
4216 pvm_meta_instruction_id_swapgtlu, /* swapgtlu */
4217 pvm_meta_instruction_id_sync, /* sync */
4218 pvm_meta_instruction_id_time, /* time */
4219 pvm_meta_instruction_id_tor, /* tor */
4220 pvm_meta_instruction_id_tuck, /* tuck */
4221 pvm_meta_instruction_id_tyagetb, /* tyagetb */
4222 pvm_meta_instruction_id_tyagett, /* tyagett */
4223 pvm_meta_instruction_id_tyisc, /* tyisc */
4224 pvm_meta_instruction_id_tyissct, /* tyissct */
4225 pvm_meta_instruction_id_typof, /* typof */
4226 pvm_meta_instruction_id_tysctn, /* tysctn */
4227 pvm_meta_instruction_id_unmap, /* unmap */
4228 pvm_meta_instruction_id_unreachable, /* unreachable */
4229 pvm_meta_instruction_id_ureloc, /* ureloc */
4230 pvm_meta_instruction_id_write, /* write/retR */
4231 pvm_meta_instruction_id_ba, /* *ba/fR*-no-fast-branches */
4232 pvm_meta_instruction_id_bn, /* *bn/fR*-no-fast-branches */
4233 pvm_meta_instruction_id_bnn, /* *bnn/fR*-no-fast-branches */
4234 pvm_meta_instruction_id_bnzi, /* *bnzi/fR*-no-fast-branches */
4235 pvm_meta_instruction_id_bnziu, /* *bnziu/fR*-no-fast-branches */
4236 pvm_meta_instruction_id_bnzl, /* *bnzl/fR*-no-fast-branches */
4237 pvm_meta_instruction_id_bnzlu, /* *bnzlu/fR*-no-fast-branches */
4238 pvm_meta_instruction_id_bzi, /* *bzi/fR*-no-fast-branches */
4239 pvm_meta_instruction_id_bziu, /* *bziu/fR*-no-fast-branches */
4240 pvm_meta_instruction_id_bzl, /* *bzl/fR*-no-fast-branches */
4241 pvm_meta_instruction_id_bzlu /* *bzlu/fR*-no-fast-branches */
4242 };
4243
4244 #ifdef JITTER_HAVE_PATCH_IN
4245 /* Worst-case defect table. */
4246 const jitter_uint
4247 pvm_worst_case_defect_table [] =
4248 {
4249 pvm_specialized_instruction_opcode__eINVALID, /* NOT potentially defective. */
4250 pvm_specialized_instruction_opcode__eBEGINBASICBLOCK, /* NOT potentially defective. */
4251 pvm_specialized_instruction_opcode__eEXITVM, /* NOT potentially defective. */
4252 pvm_specialized_instruction_opcode__eDATALOCATIONS, /* NOT potentially defective. */
4253 pvm_specialized_instruction_opcode__eNOP, /* NOT potentially defective. */
4254 pvm_specialized_instruction_opcode__eUNREACHABLE0, /* NOT potentially defective. */
4255 pvm_specialized_instruction_opcode__eUNREACHABLE1, /* NOT potentially defective. */
4256 pvm_specialized_instruction_opcode__eUNREACHABLE2, /* NOT potentially defective. */
4257 pvm_specialized_instruction_opcode_addi, /* NOT potentially defective. */
4258 pvm_specialized_instruction_opcode_addiu, /* NOT potentially defective. */
4259 pvm_specialized_instruction_opcode_addl, /* NOT potentially defective. */
4260 pvm_specialized_instruction_opcode_addlu, /* NOT potentially defective. */
4261 pvm_specialized_instruction_opcode_ains, /* NOT potentially defective. */
4262 pvm_specialized_instruction_opcode_and, /* NOT potentially defective. */
4263 pvm_specialized_instruction_opcode_aref, /* NOT potentially defective. */
4264 pvm_specialized_instruction_opcode_arefo, /* NOT potentially defective. */
4265 pvm_specialized_instruction_opcode_arem, /* NOT potentially defective. */
4266 pvm_specialized_instruction_opcode_aset, /* NOT potentially defective. */
4267 pvm_specialized_instruction_opcode_asettb, /* NOT potentially defective. */
4268 pvm_specialized_instruction_opcode_atr, /* NOT potentially defective. */
4269 /*pvm_specialized_instruction_opcode__eINVALID*/pvm_specialized_instruction_opcode__Aba__fR_A_mno_mfast_mbranches, /* POTENTIALLY DEFECTIVE. */
4270 pvm_specialized_instruction_opcode_bandi, /* NOT potentially defective. */
4271 pvm_specialized_instruction_opcode_bandiu, /* NOT potentially defective. */
4272 pvm_specialized_instruction_opcode_bandl, /* NOT potentially defective. */
4273 pvm_specialized_instruction_opcode_bandlu, /* NOT potentially defective. */
4274 pvm_specialized_instruction_opcode_beghl, /* NOT potentially defective. */
4275 pvm_specialized_instruction_opcode_begsc, /* NOT potentially defective. */
4276 /*pvm_specialized_instruction_opcode__eINVALID*/pvm_specialized_instruction_opcode__Abn__fR_A_mno_mfast_mbranches, /* POTENTIALLY DEFECTIVE. */
4277 /*pvm_specialized_instruction_opcode__eINVALID*/pvm_specialized_instruction_opcode__Abnn__fR_A_mno_mfast_mbranches, /* POTENTIALLY DEFECTIVE. */
4278 pvm_specialized_instruction_opcode_bnoti, /* NOT potentially defective. */
4279 pvm_specialized_instruction_opcode_bnotiu, /* NOT potentially defective. */
4280 pvm_specialized_instruction_opcode_bnotl, /* NOT potentially defective. */
4281 pvm_specialized_instruction_opcode_bnotlu, /* NOT potentially defective. */
4282 /*pvm_specialized_instruction_opcode__eINVALID*/pvm_specialized_instruction_opcode__Abnzi__fR_A_mno_mfast_mbranches, /* POTENTIALLY DEFECTIVE. */
4283 /*pvm_specialized_instruction_opcode__eINVALID*/pvm_specialized_instruction_opcode__Abnziu__fR_A_mno_mfast_mbranches, /* POTENTIALLY DEFECTIVE. */
4284 /*pvm_specialized_instruction_opcode__eINVALID*/pvm_specialized_instruction_opcode__Abnzl__fR_A_mno_mfast_mbranches, /* POTENTIALLY DEFECTIVE. */
4285 /*pvm_specialized_instruction_opcode__eINVALID*/pvm_specialized_instruction_opcode__Abnzlu__fR_A_mno_mfast_mbranches, /* POTENTIALLY DEFECTIVE. */
4286 pvm_specialized_instruction_opcode_bori, /* NOT potentially defective. */
4287 pvm_specialized_instruction_opcode_boriu, /* NOT potentially defective. */
4288 pvm_specialized_instruction_opcode_borl, /* NOT potentially defective. */
4289 pvm_specialized_instruction_opcode_borlu, /* NOT potentially defective. */
4290 pvm_specialized_instruction_opcode_bsli, /* NOT potentially defective. */
4291 pvm_specialized_instruction_opcode_bsliu, /* NOT potentially defective. */
4292 pvm_specialized_instruction_opcode_bsll, /* NOT potentially defective. */
4293 pvm_specialized_instruction_opcode_bsllu, /* NOT potentially defective. */
4294 pvm_specialized_instruction_opcode_bsri, /* NOT potentially defective. */
4295 pvm_specialized_instruction_opcode_bsriu, /* NOT potentially defective. */
4296 pvm_specialized_instruction_opcode_bsrl, /* NOT potentially defective. */
4297 pvm_specialized_instruction_opcode_bsrlu, /* NOT potentially defective. */
4298 pvm_specialized_instruction_opcode_bxori, /* NOT potentially defective. */
4299 pvm_specialized_instruction_opcode_bxoriu, /* NOT potentially defective. */
4300 pvm_specialized_instruction_opcode_bxorl, /* NOT potentially defective. */
4301 pvm_specialized_instruction_opcode_bxorlu, /* NOT potentially defective. */
4302 /*pvm_specialized_instruction_opcode__eINVALID*/pvm_specialized_instruction_opcode__Abzi__fR_A_mno_mfast_mbranches, /* POTENTIALLY DEFECTIVE. */
4303 /*pvm_specialized_instruction_opcode__eINVALID*/pvm_specialized_instruction_opcode__Abziu__fR_A_mno_mfast_mbranches, /* POTENTIALLY DEFECTIVE. */
4304 /*pvm_specialized_instruction_opcode__eINVALID*/pvm_specialized_instruction_opcode__Abzl__fR_A_mno_mfast_mbranches, /* POTENTIALLY DEFECTIVE. */
4305 /*pvm_specialized_instruction_opcode__eINVALID*/pvm_specialized_instruction_opcode__Abzlu__fR_A_mno_mfast_mbranches, /* POTENTIALLY DEFECTIVE. */
4306 pvm_specialized_instruction_opcode_call__retR, /* NOT potentially defective. */
4307 pvm_specialized_instruction_opcode_canary, /* NOT potentially defective. */
4308 pvm_specialized_instruction_opcode_close, /* NOT potentially defective. */
4309 pvm_specialized_instruction_opcode_ctos, /* NOT potentially defective. */
4310 pvm_specialized_instruction_opcode_disas, /* NOT potentially defective. */
4311 pvm_specialized_instruction_opcode_divi, /* NOT potentially defective. */
4312 pvm_specialized_instruction_opcode_diviu, /* NOT potentially defective. */
4313 pvm_specialized_instruction_opcode_divl, /* NOT potentially defective. */
4314 pvm_specialized_instruction_opcode_divlu, /* NOT potentially defective. */
4315 pvm_specialized_instruction_opcode_drop, /* NOT potentially defective. */
4316 pvm_specialized_instruction_opcode_drop2, /* NOT potentially defective. */
4317 pvm_specialized_instruction_opcode_drop3, /* NOT potentially defective. */
4318 pvm_specialized_instruction_opcode_drop4, /* NOT potentially defective. */
4319 pvm_specialized_instruction_opcode_duc, /* NOT potentially defective. */
4320 pvm_specialized_instruction_opcode_dup, /* NOT potentially defective. */
4321 pvm_specialized_instruction_opcode_endhl, /* NOT potentially defective. */
4322 pvm_specialized_instruction_opcode_endsc, /* NOT potentially defective. */
4323 pvm_specialized_instruction_opcode_eqi, /* NOT potentially defective. */
4324 pvm_specialized_instruction_opcode_eqiu, /* NOT potentially defective. */
4325 pvm_specialized_instruction_opcode_eql, /* NOT potentially defective. */
4326 pvm_specialized_instruction_opcode_eqlu, /* NOT potentially defective. */
4327 pvm_specialized_instruction_opcode_eqs, /* NOT potentially defective. */
4328 pvm_specialized_instruction_opcode_exit, /* NOT potentially defective. */
4329 pvm_specialized_instruction_opcode_exitvm, /* NOT potentially defective. */
4330 pvm_specialized_instruction_opcode_flush, /* NOT potentially defective. */
4331 pvm_specialized_instruction_opcode_fromr, /* NOT potentially defective. */
4332 pvm_specialized_instruction_opcode_gei, /* NOT potentially defective. */
4333 pvm_specialized_instruction_opcode_geiu, /* NOT potentially defective. */
4334 pvm_specialized_instruction_opcode_gel, /* NOT potentially defective. */
4335 pvm_specialized_instruction_opcode_gelu, /* NOT potentially defective. */
4336 pvm_specialized_instruction_opcode_ges, /* NOT potentially defective. */
4337 pvm_specialized_instruction_opcode_getenv, /* NOT potentially defective. */
4338 pvm_specialized_instruction_opcode_gti, /* NOT potentially defective. */
4339 pvm_specialized_instruction_opcode_gtiu, /* NOT potentially defective. */
4340 pvm_specialized_instruction_opcode_gtl, /* NOT potentially defective. */
4341 pvm_specialized_instruction_opcode_gtlu, /* NOT potentially defective. */
4342 pvm_specialized_instruction_opcode_gts, /* NOT potentially defective. */
4343 pvm_specialized_instruction_opcode_indent, /* NOT potentially defective. */
4344 pvm_specialized_instruction_opcode_iogetb, /* NOT potentially defective. */
4345 pvm_specialized_instruction_opcode_iosetb, /* NOT potentially defective. */
4346 pvm_specialized_instruction_opcode_iosize, /* NOT potentially defective. */
4347 pvm_specialized_instruction_opcode_isa, /* NOT potentially defective. */
4348 pvm_specialized_instruction_opcode_itoi__nR, /* NOT potentially defective. */
4349 pvm_specialized_instruction_opcode_itoiu__nR, /* NOT potentially defective. */
4350 pvm_specialized_instruction_opcode_itol__nR, /* NOT potentially defective. */
4351 pvm_specialized_instruction_opcode_itolu__nR, /* NOT potentially defective. */
4352 pvm_specialized_instruction_opcode_iutoi__nR, /* NOT potentially defective. */
4353 pvm_specialized_instruction_opcode_iutoiu__nR, /* NOT potentially defective. */
4354 pvm_specialized_instruction_opcode_iutol__nR, /* NOT potentially defective. */
4355 pvm_specialized_instruction_opcode_iutolu__nR, /* NOT potentially defective. */
4356 pvm_specialized_instruction_opcode_lei, /* NOT potentially defective. */
4357 pvm_specialized_instruction_opcode_leiu, /* NOT potentially defective. */
4358 pvm_specialized_instruction_opcode_lel, /* NOT potentially defective. */
4359 pvm_specialized_instruction_opcode_lelu, /* NOT potentially defective. */
4360 pvm_specialized_instruction_opcode_les, /* NOT potentially defective. */
4361 pvm_specialized_instruction_opcode_lti, /* NOT potentially defective. */
4362 pvm_specialized_instruction_opcode_ltiu, /* NOT potentially defective. */
4363 pvm_specialized_instruction_opcode_ltl, /* NOT potentially defective. */
4364 pvm_specialized_instruction_opcode_ltlu, /* NOT potentially defective. */
4365 pvm_specialized_instruction_opcode_ltoi__nR, /* NOT potentially defective. */
4366 pvm_specialized_instruction_opcode_ltoiu__nR, /* NOT potentially defective. */
4367 pvm_specialized_instruction_opcode_ltol__nR, /* NOT potentially defective. */
4368 pvm_specialized_instruction_opcode_ltolu__nR, /* NOT potentially defective. */
4369 pvm_specialized_instruction_opcode_lts, /* NOT potentially defective. */
4370 pvm_specialized_instruction_opcode_lutoi__nR, /* NOT potentially defective. */
4371 pvm_specialized_instruction_opcode_lutoiu__nR, /* NOT potentially defective. */
4372 pvm_specialized_instruction_opcode_lutol__nR, /* NOT potentially defective. */
4373 pvm_specialized_instruction_opcode_lutolu__nR, /* NOT potentially defective. */
4374 pvm_specialized_instruction_opcode_map, /* NOT potentially defective. */
4375 pvm_specialized_instruction_opcode_mgetios, /* NOT potentially defective. */
4376 pvm_specialized_instruction_opcode_mgetm, /* NOT potentially defective. */
4377 pvm_specialized_instruction_opcode_mgeto, /* NOT potentially defective. */
4378 pvm_specialized_instruction_opcode_mgets, /* NOT potentially defective. */
4379 pvm_specialized_instruction_opcode_mgetsel, /* NOT potentially defective. */
4380 pvm_specialized_instruction_opcode_mgetsiz, /* NOT potentially defective. */
4381 pvm_specialized_instruction_opcode_mgetw, /* NOT potentially defective. */
4382 pvm_specialized_instruction_opcode_mka, /* NOT potentially defective. */
4383 pvm_specialized_instruction_opcode_mko, /* NOT potentially defective. */
4384 pvm_specialized_instruction_opcode_mksct, /* NOT potentially defective. */
4385 pvm_specialized_instruction_opcode_mktya, /* NOT potentially defective. */
4386 pvm_specialized_instruction_opcode_mktyany, /* NOT potentially defective. */
4387 pvm_specialized_instruction_opcode_mktyc, /* NOT potentially defective. */
4388 pvm_specialized_instruction_opcode_mktyi, /* NOT potentially defective. */
4389 pvm_specialized_instruction_opcode_mktyo, /* NOT potentially defective. */
4390 pvm_specialized_instruction_opcode_mktys, /* NOT potentially defective. */
4391 pvm_specialized_instruction_opcode_mktysct, /* NOT potentially defective. */
4392 pvm_specialized_instruction_opcode_mktyv, /* NOT potentially defective. */
4393 pvm_specialized_instruction_opcode_mm, /* NOT potentially defective. */
4394 pvm_specialized_instruction_opcode_modi, /* NOT potentially defective. */
4395 pvm_specialized_instruction_opcode_modiu, /* NOT potentially defective. */
4396 pvm_specialized_instruction_opcode_modl, /* NOT potentially defective. */
4397 pvm_specialized_instruction_opcode_modlu, /* NOT potentially defective. */
4398 pvm_specialized_instruction_opcode_msetios, /* NOT potentially defective. */
4399 pvm_specialized_instruction_opcode_msetm, /* NOT potentially defective. */
4400 pvm_specialized_instruction_opcode_mseto, /* NOT potentially defective. */
4401 pvm_specialized_instruction_opcode_msets, /* NOT potentially defective. */
4402 pvm_specialized_instruction_opcode_msetsel, /* NOT potentially defective. */
4403 pvm_specialized_instruction_opcode_msetsiz, /* NOT potentially defective. */
4404 pvm_specialized_instruction_opcode_msetw, /* NOT potentially defective. */
4405 pvm_specialized_instruction_opcode_muli, /* NOT potentially defective. */
4406 pvm_specialized_instruction_opcode_muliu, /* NOT potentially defective. */
4407 pvm_specialized_instruction_opcode_mull, /* NOT potentially defective. */
4408 pvm_specialized_instruction_opcode_mullu, /* NOT potentially defective. */
4409 pvm_specialized_instruction_opcode_muls, /* NOT potentially defective. */
4410 pvm_specialized_instruction_opcode_negi, /* NOT potentially defective. */
4411 pvm_specialized_instruction_opcode_negiu, /* NOT potentially defective. */
4412 pvm_specialized_instruction_opcode_negl, /* NOT potentially defective. */
4413 pvm_specialized_instruction_opcode_neglu, /* NOT potentially defective. */
4414 pvm_specialized_instruction_opcode_nei, /* NOT potentially defective. */
4415 pvm_specialized_instruction_opcode_neiu, /* NOT potentially defective. */
4416 pvm_specialized_instruction_opcode_nel, /* NOT potentially defective. */
4417 pvm_specialized_instruction_opcode_nelu, /* NOT potentially defective. */
4418 pvm_specialized_instruction_opcode_nes, /* NOT potentially defective. */
4419 pvm_specialized_instruction_opcode_nip, /* NOT potentially defective. */
4420 pvm_specialized_instruction_opcode_nip2, /* NOT potentially defective. */
4421 pvm_specialized_instruction_opcode_nip3, /* NOT potentially defective. */
4422 pvm_specialized_instruction_opcode_nn, /* NOT potentially defective. */
4423 pvm_specialized_instruction_opcode_nnn, /* NOT potentially defective. */
4424 pvm_specialized_instruction_opcode_nop, /* NOT potentially defective. */
4425 pvm_specialized_instruction_opcode_not, /* NOT potentially defective. */
4426 pvm_specialized_instruction_opcode_note__nR, /* NOT potentially defective. */
4427 pvm_specialized_instruction_opcode_nrot, /* NOT potentially defective. */
4428 pvm_specialized_instruction_opcode_ogetbt, /* NOT potentially defective. */
4429 pvm_specialized_instruction_opcode_ogetm, /* NOT potentially defective. */
4430 pvm_specialized_instruction_opcode_ogetu, /* NOT potentially defective. */
4431 pvm_specialized_instruction_opcode_open, /* NOT potentially defective. */
4432 pvm_specialized_instruction_opcode_or, /* NOT potentially defective. */
4433 pvm_specialized_instruction_opcode_osetm, /* NOT potentially defective. */
4434 pvm_specialized_instruction_opcode_over, /* NOT potentially defective. */
4435 pvm_specialized_instruction_opcode_pec, /* NOT potentially defective. */
4436 pvm_specialized_instruction_opcode_peekdi__nR, /* NOT potentially defective. */
4437 pvm_specialized_instruction_opcode_peekdiu__nR, /* NOT potentially defective. */
4438 pvm_specialized_instruction_opcode_peekdl__nR, /* NOT potentially defective. */
4439 pvm_specialized_instruction_opcode_peekdlu__nR, /* NOT potentially defective. */
4440 pvm_specialized_instruction_opcode_peeki__nR__nR__nR, /* NOT potentially defective. */
4441 pvm_specialized_instruction_opcode_peekiu__nR__nR, /* NOT potentially defective. */
4442 pvm_specialized_instruction_opcode_peekl__nR__nR__nR, /* NOT potentially defective. */
4443 pvm_specialized_instruction_opcode_peeklu__nR__nR, /* NOT potentially defective. */
4444 pvm_specialized_instruction_opcode_peeks, /* NOT potentially defective. */
4445 pvm_specialized_instruction_opcode_pokedi__nR, /* NOT potentially defective. */
4446 pvm_specialized_instruction_opcode_pokediu__nR, /* NOT potentially defective. */
4447 pvm_specialized_instruction_opcode_pokedl__nR, /* NOT potentially defective. */
4448 pvm_specialized_instruction_opcode_pokedlu__nR, /* NOT potentially defective. */
4449 pvm_specialized_instruction_opcode_pokei__nR__nR__nR, /* NOT potentially defective. */
4450 pvm_specialized_instruction_opcode_pokeiu__nR__nR, /* NOT potentially defective. */
4451 pvm_specialized_instruction_opcode_pokel__nR__nR__nR, /* NOT potentially defective. */
4452 pvm_specialized_instruction_opcode_pokelu__nR__nR, /* NOT potentially defective. */
4453 pvm_specialized_instruction_opcode_pokes, /* NOT potentially defective. */
4454 pvm_specialized_instruction_opcode_pope, /* NOT potentially defective. */
4455 pvm_specialized_instruction_opcode_popend, /* NOT potentially defective. */
4456 pvm_specialized_instruction_opcode_popf__nR, /* NOT potentially defective. */
4457 pvm_specialized_instruction_opcode_popios, /* NOT potentially defective. */
4458 pvm_specialized_instruction_opcode_popoac, /* NOT potentially defective. */
4459 pvm_specialized_instruction_opcode_popob, /* NOT potentially defective. */
4460 pvm_specialized_instruction_opcode_popobc, /* NOT potentially defective. */
4461 pvm_specialized_instruction_opcode_popoc, /* NOT potentially defective. */
4462 pvm_specialized_instruction_opcode_popod, /* NOT potentially defective. */
4463 pvm_specialized_instruction_opcode_popoi, /* NOT potentially defective. */
4464 pvm_specialized_instruction_opcode_popom, /* NOT potentially defective. */
4465 pvm_specialized_instruction_opcode_popoo, /* NOT potentially defective. */
4466 pvm_specialized_instruction_opcode_popopp, /* NOT potentially defective. */
4467 pvm_specialized_instruction_opcode_popr___rrR, /* NOT potentially defective. */
4468 pvm_specialized_instruction_opcode_popvar__nR__nR, /* NOT potentially defective. */
4469 pvm_specialized_instruction_opcode_powi, /* NOT potentially defective. */
4470 pvm_specialized_instruction_opcode_powiu, /* NOT potentially defective. */
4471 pvm_specialized_instruction_opcode_powl, /* NOT potentially defective. */
4472 pvm_specialized_instruction_opcode_powlu, /* NOT potentially defective. */
4473 pvm_specialized_instruction_opcode_printi__nR, /* NOT potentially defective. */
4474 pvm_specialized_instruction_opcode_printiu__nR, /* NOT potentially defective. */
4475 pvm_specialized_instruction_opcode_printl__nR, /* NOT potentially defective. */
4476 pvm_specialized_instruction_opcode_printlu__nR, /* NOT potentially defective. */
4477 pvm_specialized_instruction_opcode_prints, /* NOT potentially defective. */
4478 pvm_specialized_instruction_opcode_prolog, /* NOT potentially defective. */
4479 pvm_specialized_instruction_opcode_push__nR, /* NOT potentially defective. */
4480 pvm_specialized_instruction_opcode_push__lR, /* NOT potentially defective. */
4481 pvm_specialized_instruction_opcode_push32__nR, /* NOT potentially defective. */
4482 pvm_specialized_instruction_opcode_push32__lR, /* NOT potentially defective. */
4483 pvm_specialized_instruction_opcode_pushe__lR, /* NOT potentially defective. */
4484 pvm_specialized_instruction_opcode_pushend, /* NOT potentially defective. */
4485 pvm_specialized_instruction_opcode_pushf__nR, /* NOT potentially defective. */
4486 pvm_specialized_instruction_opcode_pushhi__nR, /* NOT potentially defective. */
4487 pvm_specialized_instruction_opcode_pushhi__lR, /* NOT potentially defective. */
4488 pvm_specialized_instruction_opcode_pushios, /* NOT potentially defective. */
4489 pvm_specialized_instruction_opcode_pushlo__nR, /* NOT potentially defective. */
4490 pvm_specialized_instruction_opcode_pushlo__lR, /* NOT potentially defective. */
4491 pvm_specialized_instruction_opcode_pushoac, /* NOT potentially defective. */
4492 pvm_specialized_instruction_opcode_pushob, /* NOT potentially defective. */
4493 pvm_specialized_instruction_opcode_pushobc, /* NOT potentially defective. */
4494 pvm_specialized_instruction_opcode_pushoc, /* NOT potentially defective. */
4495 pvm_specialized_instruction_opcode_pushod, /* NOT potentially defective. */
4496 pvm_specialized_instruction_opcode_pushoi, /* NOT potentially defective. */
4497 pvm_specialized_instruction_opcode_pushom, /* NOT potentially defective. */
4498 pvm_specialized_instruction_opcode_pushoo, /* NOT potentially defective. */
4499 pvm_specialized_instruction_opcode_pushopp, /* NOT potentially defective. */
4500 pvm_specialized_instruction_opcode_pushr___rrR, /* NOT potentially defective. */
4501 pvm_specialized_instruction_opcode_pushtopvar__nR, /* NOT potentially defective. */
4502 pvm_specialized_instruction_opcode_pushvar__n0__n0, /* NOT potentially defective. */
4503 pvm_specialized_instruction_opcode_pushvar__n0__n1, /* NOT potentially defective. */
4504 pvm_specialized_instruction_opcode_pushvar__n0__n2, /* NOT potentially defective. */
4505 pvm_specialized_instruction_opcode_pushvar__n0__n3, /* NOT potentially defective. */
4506 pvm_specialized_instruction_opcode_pushvar__n0__n4, /* NOT potentially defective. */
4507 pvm_specialized_instruction_opcode_pushvar__n0__n5, /* NOT potentially defective. */
4508 pvm_specialized_instruction_opcode_pushvar__n0__nR, /* NOT potentially defective. */
4509 pvm_specialized_instruction_opcode_pushvar__nR__n0, /* NOT potentially defective. */
4510 pvm_specialized_instruction_opcode_pushvar__nR__n1, /* NOT potentially defective. */
4511 pvm_specialized_instruction_opcode_pushvar__nR__n2, /* NOT potentially defective. */
4512 pvm_specialized_instruction_opcode_pushvar__nR__n3, /* NOT potentially defective. */
4513 pvm_specialized_instruction_opcode_pushvar__nR__n4, /* NOT potentially defective. */
4514 pvm_specialized_instruction_opcode_pushvar__nR__n5, /* NOT potentially defective. */
4515 pvm_specialized_instruction_opcode_pushvar__nR__nR, /* NOT potentially defective. */
4516 pvm_specialized_instruction_opcode_quake, /* NOT potentially defective. */
4517 pvm_specialized_instruction_opcode_raise, /* NOT potentially defective. */
4518 pvm_specialized_instruction_opcode_rand, /* NOT potentially defective. */
4519 pvm_specialized_instruction_opcode_regvar, /* NOT potentially defective. */
4520 pvm_specialized_instruction_opcode_reloc, /* NOT potentially defective. */
4521 pvm_specialized_instruction_opcode_restorer___rrR, /* NOT potentially defective. */
4522 pvm_specialized_instruction_opcode_return, /* NOT potentially defective. */
4523 pvm_specialized_instruction_opcode_revn__n3, /* NOT potentially defective. */
4524 pvm_specialized_instruction_opcode_revn__n4, /* NOT potentially defective. */
4525 pvm_specialized_instruction_opcode_revn__nR, /* NOT potentially defective. */
4526 pvm_specialized_instruction_opcode_rot, /* NOT potentially defective. */
4527 pvm_specialized_instruction_opcode_saver___rrR, /* NOT potentially defective. */
4528 pvm_specialized_instruction_opcode_sconc, /* NOT potentially defective. */
4529 pvm_specialized_instruction_opcode_sel, /* NOT potentially defective. */
4530 pvm_specialized_instruction_opcode_setr___rrR, /* NOT potentially defective. */
4531 pvm_specialized_instruction_opcode_siz, /* NOT potentially defective. */
4532 pvm_specialized_instruction_opcode_smodi, /* NOT potentially defective. */
4533 pvm_specialized_instruction_opcode_sref, /* NOT potentially defective. */
4534 pvm_specialized_instruction_opcode_srefi, /* NOT potentially defective. */
4535 pvm_specialized_instruction_opcode_srefia, /* NOT potentially defective. */
4536 pvm_specialized_instruction_opcode_srefio, /* NOT potentially defective. */
4537 pvm_specialized_instruction_opcode_srefmnt, /* NOT potentially defective. */
4538 pvm_specialized_instruction_opcode_srefnt, /* NOT potentially defective. */
4539 pvm_specialized_instruction_opcode_srefo, /* NOT potentially defective. */
4540 pvm_specialized_instruction_opcode_sset, /* NOT potentially defective. */
4541 pvm_specialized_instruction_opcode_strace__nR, /* NOT potentially defective. */
4542 pvm_specialized_instruction_opcode_strref, /* NOT potentially defective. */
4543 pvm_specialized_instruction_opcode_subi, /* NOT potentially defective. */
4544 pvm_specialized_instruction_opcode_subiu, /* NOT potentially defective. */
4545 pvm_specialized_instruction_opcode_subl, /* NOT potentially defective. */
4546 pvm_specialized_instruction_opcode_sublu, /* NOT potentially defective. */
4547 pvm_specialized_instruction_opcode_substr, /* NOT potentially defective. */
4548 pvm_specialized_instruction_opcode_swap, /* NOT potentially defective. */
4549 pvm_specialized_instruction_opcode_swapgti, /* NOT potentially defective. */
4550 pvm_specialized_instruction_opcode_swapgtiu, /* NOT potentially defective. */
4551 pvm_specialized_instruction_opcode_swapgtl, /* NOT potentially defective. */
4552 pvm_specialized_instruction_opcode_swapgtlu, /* NOT potentially defective. */
4553 pvm_specialized_instruction_opcode_sync, /* NOT potentially defective. */
4554 pvm_specialized_instruction_opcode_time, /* NOT potentially defective. */
4555 pvm_specialized_instruction_opcode_tor, /* NOT potentially defective. */
4556 pvm_specialized_instruction_opcode_tuck, /* NOT potentially defective. */
4557 pvm_specialized_instruction_opcode_tyagetb, /* NOT potentially defective. */
4558 pvm_specialized_instruction_opcode_tyagett, /* NOT potentially defective. */
4559 pvm_specialized_instruction_opcode_tyisc, /* NOT potentially defective. */
4560 pvm_specialized_instruction_opcode_tyissct, /* NOT potentially defective. */
4561 pvm_specialized_instruction_opcode_typof, /* NOT potentially defective. */
4562 pvm_specialized_instruction_opcode_tysctn, /* NOT potentially defective. */
4563 pvm_specialized_instruction_opcode_unmap, /* NOT potentially defective. */
4564 pvm_specialized_instruction_opcode_unreachable, /* NOT potentially defective. */
4565 pvm_specialized_instruction_opcode_ureloc, /* NOT potentially defective. */
4566 pvm_specialized_instruction_opcode_write__retR, /* NOT potentially defective. */
4567 pvm_specialized_instruction_opcode__Aba__fR_A_mno_mfast_mbranches, /* NOT potentially defective. */
4568 pvm_specialized_instruction_opcode__Abn__fR_A_mno_mfast_mbranches, /* NOT potentially defective. */
4569 pvm_specialized_instruction_opcode__Abnn__fR_A_mno_mfast_mbranches, /* NOT potentially defective. */
4570 pvm_specialized_instruction_opcode__Abnzi__fR_A_mno_mfast_mbranches, /* NOT potentially defective. */
4571 pvm_specialized_instruction_opcode__Abnziu__fR_A_mno_mfast_mbranches, /* NOT potentially defective. */
4572 pvm_specialized_instruction_opcode__Abnzl__fR_A_mno_mfast_mbranches, /* NOT potentially defective. */
4573 pvm_specialized_instruction_opcode__Abnzlu__fR_A_mno_mfast_mbranches, /* NOT potentially defective. */
4574 pvm_specialized_instruction_opcode__Abzi__fR_A_mno_mfast_mbranches, /* NOT potentially defective. */
4575 pvm_specialized_instruction_opcode__Abziu__fR_A_mno_mfast_mbranches, /* NOT potentially defective. */
4576 pvm_specialized_instruction_opcode__Abzl__fR_A_mno_mfast_mbranches, /* NOT potentially defective. */
4577 pvm_specialized_instruction_opcode__Abzlu__fR_A_mno_mfast_mbranches /* NOT potentially defective. */
4578 };
4579 #endif // #ifdef JITTER_HAVE_PATCH_IN
4580
4581
4582 void
pvm_rewrite(struct jitter_mutable_routine * jitter_mutable_routine_p)4583 pvm_rewrite (struct jitter_mutable_routine *jitter_mutable_routine_p)
4584 {
4585 JITTTER_REWRITE_FUNCTION_PROLOG_;
4586
4587 /* User-specified code, rewriter part: beginning. */
4588
4589 /* User-specified code, rewriter part: end */
4590
4591
4592 //asm volatile ("\n# checking swap-drop-to-nip");
4593 //fprintf (stderr, "Trying rule 1 of 9, \"swap-drop-to-nip\" (line 5794)\n");
4594 /* Rewrite rule "swap-drop-to-nip" */
4595 #line 5794 "../../libpoke/pvm.jitter"
4596 JITTER_RULE_BEGIN(2)
4597 JITTER_RULE_BEGIN_PLACEHOLDER_DECLARATIONS
4598 JITTER_RULE_END_PLACEHOLDER_DECLARATIONS
4599 JITTER_RULE_BEGIN_CONDITIONS
4600 /* Check opcodes first: they are likely not to match, and in */
4601 /* that case we want to fail as early as possible. */
4602 #line 5791 "../../libpoke/pvm.jitter"
4603 JITTER_RULE_CONDITION_MATCH_OPCODE(0, swap)
4604 #line 5792 "../../libpoke/pvm.jitter"
4605 JITTER_RULE_CONDITION_MATCH_OPCODE(1, drop)
4606 /* Check arguments, binding placeholders. We don't have to worry */
4607 /* about arity, since the opcodes match if we're here. */
4608 /* Rule guard. */
4609 JITTER_RULE_CONDITION(
4610 #line 5794 "../../libpoke/pvm.jitter"
4611 true
4612 )
4613 JITTER_RULE_END_CONDITIONS
4614 JITTER_RULE_BEGIN_PLACEHOLDER_CLONING
4615 JITTER_RULE_END_PLACEHOLDER_CLONING
4616 JITTER_RULE_BEGIN_BODY
4617 //fprintf (stderr, "* The rule swap-drop-to-nip (line 5794) fires...\n");
4618 #line 5794 "../../libpoke/pvm.jitter"
4619 //fprintf (stderr, " rewrite: adding instruction nip\n");
4620 JITTER_RULE_APPEND_INSTRUCTION_(nip);
4621 //fprintf (stderr, " ...End of the rule swap-drop-to-nip\n");
4622 JITTER_RULE_END_BODY
4623 JITTER_RULE_BEGIN_PLACEHOLDER_DESTRUCTION
4624 JITTER_RULE_END_PLACEHOLDER_DESTRUCTION
4625 JITTER_RULE_END
4626
4627 //asm volatile ("\n# checking rot-rot-to-nrot");
4628 //fprintf (stderr, "Trying rule 2 of 9, \"rot-rot-to-nrot\" (line 5800)\n");
4629 /* Rewrite rule "rot-rot-to-nrot" */
4630 #line 5800 "../../libpoke/pvm.jitter"
4631 JITTER_RULE_BEGIN(2)
4632 JITTER_RULE_BEGIN_PLACEHOLDER_DECLARATIONS
4633 JITTER_RULE_END_PLACEHOLDER_DECLARATIONS
4634 JITTER_RULE_BEGIN_CONDITIONS
4635 /* Check opcodes first: they are likely not to match, and in */
4636 /* that case we want to fail as early as possible. */
4637 #line 5797 "../../libpoke/pvm.jitter"
4638 JITTER_RULE_CONDITION_MATCH_OPCODE(0, rot)
4639 #line 5798 "../../libpoke/pvm.jitter"
4640 JITTER_RULE_CONDITION_MATCH_OPCODE(1, rot)
4641 /* Check arguments, binding placeholders. We don't have to worry */
4642 /* about arity, since the opcodes match if we're here. */
4643 /* Rule guard. */
4644 JITTER_RULE_CONDITION(
4645 #line 5800 "../../libpoke/pvm.jitter"
4646 true
4647 )
4648 JITTER_RULE_END_CONDITIONS
4649 JITTER_RULE_BEGIN_PLACEHOLDER_CLONING
4650 JITTER_RULE_END_PLACEHOLDER_CLONING
4651 JITTER_RULE_BEGIN_BODY
4652 //fprintf (stderr, "* The rule rot-rot-to-nrot (line 5800) fires...\n");
4653 #line 5800 "../../libpoke/pvm.jitter"
4654 //fprintf (stderr, " rewrite: adding instruction nrot\n");
4655 JITTER_RULE_APPEND_INSTRUCTION_(nrot);
4656 //fprintf (stderr, " ...End of the rule rot-rot-to-nrot\n");
4657 JITTER_RULE_END_BODY
4658 JITTER_RULE_BEGIN_PLACEHOLDER_DESTRUCTION
4659 JITTER_RULE_END_PLACEHOLDER_DESTRUCTION
4660 JITTER_RULE_END
4661
4662 //asm volatile ("\n# checking nip-nip-to-nip2");
4663 //fprintf (stderr, "Trying rule 3 of 9, \"nip-nip-to-nip2\" (line 5806)\n");
4664 /* Rewrite rule "nip-nip-to-nip2" */
4665 #line 5806 "../../libpoke/pvm.jitter"
4666 JITTER_RULE_BEGIN(2)
4667 JITTER_RULE_BEGIN_PLACEHOLDER_DECLARATIONS
4668 JITTER_RULE_END_PLACEHOLDER_DECLARATIONS
4669 JITTER_RULE_BEGIN_CONDITIONS
4670 /* Check opcodes first: they are likely not to match, and in */
4671 /* that case we want to fail as early as possible. */
4672 #line 5803 "../../libpoke/pvm.jitter"
4673 JITTER_RULE_CONDITION_MATCH_OPCODE(0, nip)
4674 #line 5804 "../../libpoke/pvm.jitter"
4675 JITTER_RULE_CONDITION_MATCH_OPCODE(1, nip)
4676 /* Check arguments, binding placeholders. We don't have to worry */
4677 /* about arity, since the opcodes match if we're here. */
4678 /* Rule guard. */
4679 JITTER_RULE_CONDITION(
4680 #line 5806 "../../libpoke/pvm.jitter"
4681 true
4682 )
4683 JITTER_RULE_END_CONDITIONS
4684 JITTER_RULE_BEGIN_PLACEHOLDER_CLONING
4685 JITTER_RULE_END_PLACEHOLDER_CLONING
4686 JITTER_RULE_BEGIN_BODY
4687 //fprintf (stderr, "* The rule nip-nip-to-nip2 (line 5806) fires...\n");
4688 #line 5806 "../../libpoke/pvm.jitter"
4689 //fprintf (stderr, " rewrite: adding instruction nip2\n");
4690 JITTER_RULE_APPEND_INSTRUCTION_(nip2);
4691 //fprintf (stderr, " ...End of the rule nip-nip-to-nip2\n");
4692 JITTER_RULE_END_BODY
4693 JITTER_RULE_BEGIN_PLACEHOLDER_DESTRUCTION
4694 JITTER_RULE_END_PLACEHOLDER_DESTRUCTION
4695 JITTER_RULE_END
4696
4697 //asm volatile ("\n# checking nip2-nip-to-nip3");
4698 //fprintf (stderr, "Trying rule 4 of 9, \"nip2-nip-to-nip3\" (line 5812)\n");
4699 /* Rewrite rule "nip2-nip-to-nip3" */
4700 #line 5812 "../../libpoke/pvm.jitter"
4701 JITTER_RULE_BEGIN(2)
4702 JITTER_RULE_BEGIN_PLACEHOLDER_DECLARATIONS
4703 JITTER_RULE_END_PLACEHOLDER_DECLARATIONS
4704 JITTER_RULE_BEGIN_CONDITIONS
4705 /* Check opcodes first: they are likely not to match, and in */
4706 /* that case we want to fail as early as possible. */
4707 #line 5809 "../../libpoke/pvm.jitter"
4708 JITTER_RULE_CONDITION_MATCH_OPCODE(0, nip2)
4709 #line 5810 "../../libpoke/pvm.jitter"
4710 JITTER_RULE_CONDITION_MATCH_OPCODE(1, nip)
4711 /* Check arguments, binding placeholders. We don't have to worry */
4712 /* about arity, since the opcodes match if we're here. */
4713 /* Rule guard. */
4714 JITTER_RULE_CONDITION(
4715 #line 5812 "../../libpoke/pvm.jitter"
4716 true
4717 )
4718 JITTER_RULE_END_CONDITIONS
4719 JITTER_RULE_BEGIN_PLACEHOLDER_CLONING
4720 JITTER_RULE_END_PLACEHOLDER_CLONING
4721 JITTER_RULE_BEGIN_BODY
4722 //fprintf (stderr, "* The rule nip2-nip-to-nip3 (line 5812) fires...\n");
4723 #line 5812 "../../libpoke/pvm.jitter"
4724 //fprintf (stderr, " rewrite: adding instruction nip3\n");
4725 JITTER_RULE_APPEND_INSTRUCTION_(nip3);
4726 //fprintf (stderr, " ...End of the rule nip2-nip-to-nip3\n");
4727 JITTER_RULE_END_BODY
4728 JITTER_RULE_BEGIN_PLACEHOLDER_DESTRUCTION
4729 JITTER_RULE_END_PLACEHOLDER_DESTRUCTION
4730 JITTER_RULE_END
4731
4732 //asm volatile ("\n# checking drop-drop-to-drop2");
4733 //fprintf (stderr, "Trying rule 5 of 9, \"drop-drop-to-drop2\" (line 5818)\n");
4734 /* Rewrite rule "drop-drop-to-drop2" */
4735 #line 5818 "../../libpoke/pvm.jitter"
4736 JITTER_RULE_BEGIN(2)
4737 JITTER_RULE_BEGIN_PLACEHOLDER_DECLARATIONS
4738 JITTER_RULE_END_PLACEHOLDER_DECLARATIONS
4739 JITTER_RULE_BEGIN_CONDITIONS
4740 /* Check opcodes first: they are likely not to match, and in */
4741 /* that case we want to fail as early as possible. */
4742 #line 5815 "../../libpoke/pvm.jitter"
4743 JITTER_RULE_CONDITION_MATCH_OPCODE(0, drop)
4744 #line 5816 "../../libpoke/pvm.jitter"
4745 JITTER_RULE_CONDITION_MATCH_OPCODE(1, drop)
4746 /* Check arguments, binding placeholders. We don't have to worry */
4747 /* about arity, since the opcodes match if we're here. */
4748 /* Rule guard. */
4749 JITTER_RULE_CONDITION(
4750 #line 5818 "../../libpoke/pvm.jitter"
4751 true
4752 )
4753 JITTER_RULE_END_CONDITIONS
4754 JITTER_RULE_BEGIN_PLACEHOLDER_CLONING
4755 JITTER_RULE_END_PLACEHOLDER_CLONING
4756 JITTER_RULE_BEGIN_BODY
4757 //fprintf (stderr, "* The rule drop-drop-to-drop2 (line 5818) fires...\n");
4758 #line 5818 "../../libpoke/pvm.jitter"
4759 //fprintf (stderr, " rewrite: adding instruction drop2\n");
4760 JITTER_RULE_APPEND_INSTRUCTION_(drop2);
4761 //fprintf (stderr, " ...End of the rule drop-drop-to-drop2\n");
4762 JITTER_RULE_END_BODY
4763 JITTER_RULE_BEGIN_PLACEHOLDER_DESTRUCTION
4764 JITTER_RULE_END_PLACEHOLDER_DESTRUCTION
4765 JITTER_RULE_END
4766
4767 //asm volatile ("\n# checking drop2-drop-to-drop3");
4768 //fprintf (stderr, "Trying rule 6 of 9, \"drop2-drop-to-drop3\" (line 5824)\n");
4769 /* Rewrite rule "drop2-drop-to-drop3" */
4770 #line 5824 "../../libpoke/pvm.jitter"
4771 JITTER_RULE_BEGIN(2)
4772 JITTER_RULE_BEGIN_PLACEHOLDER_DECLARATIONS
4773 JITTER_RULE_END_PLACEHOLDER_DECLARATIONS
4774 JITTER_RULE_BEGIN_CONDITIONS
4775 /* Check opcodes first: they are likely not to match, and in */
4776 /* that case we want to fail as early as possible. */
4777 #line 5821 "../../libpoke/pvm.jitter"
4778 JITTER_RULE_CONDITION_MATCH_OPCODE(0, drop2)
4779 #line 5822 "../../libpoke/pvm.jitter"
4780 JITTER_RULE_CONDITION_MATCH_OPCODE(1, drop)
4781 /* Check arguments, binding placeholders. We don't have to worry */
4782 /* about arity, since the opcodes match if we're here. */
4783 /* Rule guard. */
4784 JITTER_RULE_CONDITION(
4785 #line 5824 "../../libpoke/pvm.jitter"
4786 true
4787 )
4788 JITTER_RULE_END_CONDITIONS
4789 JITTER_RULE_BEGIN_PLACEHOLDER_CLONING
4790 JITTER_RULE_END_PLACEHOLDER_CLONING
4791 JITTER_RULE_BEGIN_BODY
4792 //fprintf (stderr, "* The rule drop2-drop-to-drop3 (line 5824) fires...\n");
4793 #line 5824 "../../libpoke/pvm.jitter"
4794 //fprintf (stderr, " rewrite: adding instruction drop3\n");
4795 JITTER_RULE_APPEND_INSTRUCTION_(drop3);
4796 //fprintf (stderr, " ...End of the rule drop2-drop-to-drop3\n");
4797 JITTER_RULE_END_BODY
4798 JITTER_RULE_BEGIN_PLACEHOLDER_DESTRUCTION
4799 JITTER_RULE_END_PLACEHOLDER_DESTRUCTION
4800 JITTER_RULE_END
4801
4802 //asm volatile ("\n# checking drop3-drop-to-drop4");
4803 //fprintf (stderr, "Trying rule 7 of 9, \"drop3-drop-to-drop4\" (line 5830)\n");
4804 /* Rewrite rule "drop3-drop-to-drop4" */
4805 #line 5830 "../../libpoke/pvm.jitter"
4806 JITTER_RULE_BEGIN(2)
4807 JITTER_RULE_BEGIN_PLACEHOLDER_DECLARATIONS
4808 JITTER_RULE_END_PLACEHOLDER_DECLARATIONS
4809 JITTER_RULE_BEGIN_CONDITIONS
4810 /* Check opcodes first: they are likely not to match, and in */
4811 /* that case we want to fail as early as possible. */
4812 #line 5827 "../../libpoke/pvm.jitter"
4813 JITTER_RULE_CONDITION_MATCH_OPCODE(0, drop3)
4814 #line 5828 "../../libpoke/pvm.jitter"
4815 JITTER_RULE_CONDITION_MATCH_OPCODE(1, drop)
4816 /* Check arguments, binding placeholders. We don't have to worry */
4817 /* about arity, since the opcodes match if we're here. */
4818 /* Rule guard. */
4819 JITTER_RULE_CONDITION(
4820 #line 5830 "../../libpoke/pvm.jitter"
4821 true
4822 )
4823 JITTER_RULE_END_CONDITIONS
4824 JITTER_RULE_BEGIN_PLACEHOLDER_CLONING
4825 JITTER_RULE_END_PLACEHOLDER_CLONING
4826 JITTER_RULE_BEGIN_BODY
4827 //fprintf (stderr, "* The rule drop3-drop-to-drop4 (line 5830) fires...\n");
4828 #line 5830 "../../libpoke/pvm.jitter"
4829 //fprintf (stderr, " rewrite: adding instruction drop4\n");
4830 JITTER_RULE_APPEND_INSTRUCTION_(drop4);
4831 //fprintf (stderr, " ...End of the rule drop3-drop-to-drop4\n");
4832 JITTER_RULE_END_BODY
4833 JITTER_RULE_BEGIN_PLACEHOLDER_DESTRUCTION
4834 JITTER_RULE_END_PLACEHOLDER_DESTRUCTION
4835 JITTER_RULE_END
4836
4837 //asm volatile ("\n# checking swap-over-to-tuck");
4838 //fprintf (stderr, "Trying rule 8 of 9, \"swap-over-to-tuck\" (line 5836)\n");
4839 /* Rewrite rule "swap-over-to-tuck" */
4840 #line 5836 "../../libpoke/pvm.jitter"
4841 JITTER_RULE_BEGIN(2)
4842 JITTER_RULE_BEGIN_PLACEHOLDER_DECLARATIONS
4843 JITTER_RULE_END_PLACEHOLDER_DECLARATIONS
4844 JITTER_RULE_BEGIN_CONDITIONS
4845 /* Check opcodes first: they are likely not to match, and in */
4846 /* that case we want to fail as early as possible. */
4847 #line 5833 "../../libpoke/pvm.jitter"
4848 JITTER_RULE_CONDITION_MATCH_OPCODE(0, swap)
4849 #line 5834 "../../libpoke/pvm.jitter"
4850 JITTER_RULE_CONDITION_MATCH_OPCODE(1, over)
4851 /* Check arguments, binding placeholders. We don't have to worry */
4852 /* about arity, since the opcodes match if we're here. */
4853 /* Rule guard. */
4854 JITTER_RULE_CONDITION(
4855 #line 5836 "../../libpoke/pvm.jitter"
4856 true
4857 )
4858 JITTER_RULE_END_CONDITIONS
4859 JITTER_RULE_BEGIN_PLACEHOLDER_CLONING
4860 JITTER_RULE_END_PLACEHOLDER_CLONING
4861 JITTER_RULE_BEGIN_BODY
4862 //fprintf (stderr, "* The rule swap-over-to-tuck (line 5836) fires...\n");
4863 #line 5836 "../../libpoke/pvm.jitter"
4864 //fprintf (stderr, " rewrite: adding instruction tuck\n");
4865 JITTER_RULE_APPEND_INSTRUCTION_(tuck);
4866 //fprintf (stderr, " ...End of the rule swap-over-to-tuck\n");
4867 JITTER_RULE_END_BODY
4868 JITTER_RULE_BEGIN_PLACEHOLDER_DESTRUCTION
4869 JITTER_RULE_END_PLACEHOLDER_DESTRUCTION
4870 JITTER_RULE_END
4871
4872 //asm volatile ("\n# checking rot-swap-to-quake");
4873 //fprintf (stderr, "Trying rule 9 of 9, \"rot-swap-to-quake\" (line 5842)\n");
4874 /* Rewrite rule "rot-swap-to-quake" */
4875 #line 5842 "../../libpoke/pvm.jitter"
4876 JITTER_RULE_BEGIN(2)
4877 JITTER_RULE_BEGIN_PLACEHOLDER_DECLARATIONS
4878 JITTER_RULE_END_PLACEHOLDER_DECLARATIONS
4879 JITTER_RULE_BEGIN_CONDITIONS
4880 /* Check opcodes first: they are likely not to match, and in */
4881 /* that case we want to fail as early as possible. */
4882 #line 5839 "../../libpoke/pvm.jitter"
4883 JITTER_RULE_CONDITION_MATCH_OPCODE(0, rot)
4884 #line 5840 "../../libpoke/pvm.jitter"
4885 JITTER_RULE_CONDITION_MATCH_OPCODE(1, swap)
4886 /* Check arguments, binding placeholders. We don't have to worry */
4887 /* about arity, since the opcodes match if we're here. */
4888 /* Rule guard. */
4889 JITTER_RULE_CONDITION(
4890 #line 5842 "../../libpoke/pvm.jitter"
4891 true
4892 )
4893 JITTER_RULE_END_CONDITIONS
4894 JITTER_RULE_BEGIN_PLACEHOLDER_CLONING
4895 JITTER_RULE_END_PLACEHOLDER_CLONING
4896 JITTER_RULE_BEGIN_BODY
4897 //fprintf (stderr, "* The rule rot-swap-to-quake (line 5842) fires...\n");
4898 #line 5842 "../../libpoke/pvm.jitter"
4899 //fprintf (stderr, " rewrite: adding instruction quake\n");
4900 JITTER_RULE_APPEND_INSTRUCTION_(quake);
4901 //fprintf (stderr, " ...End of the rule rot-swap-to-quake\n");
4902 JITTER_RULE_END_BODY
4903 JITTER_RULE_BEGIN_PLACEHOLDER_DESTRUCTION
4904 JITTER_RULE_END_PLACEHOLDER_DESTRUCTION
4905 JITTER_RULE_END
4906
4907 //fprintf (stderr, "No more rules to try\n");
4908 }
4909
4910
4911 //#include <jitter/jitter-fatal.h>
4912
4913 //#include <jitter/jitter.h>
4914 //#include <jitter/jitter-instruction.h>
4915 //#include <jitter/jitter-specialize.h>
4916
4917 //#include "pvm-vm.h"
4918 //#include "pvm-meta-instructions.h"
4919 //#include "pvm-specialized-instructions.h"
4920
4921
4922 /* Recognizer function prototypes. */
4923 inline static enum pvm_specialized_instruction_opcode
4924 pvm_recognize_specialized_instruction_addi (struct jitter_parameter ** const ps,
4925 bool enable_fast_literals)
4926 __attribute__ ((pure));
4927 inline static enum pvm_specialized_instruction_opcode
4928 pvm_recognize_specialized_instruction_addiu (struct jitter_parameter ** const ps,
4929 bool enable_fast_literals)
4930 __attribute__ ((pure));
4931 inline static enum pvm_specialized_instruction_opcode
4932 pvm_recognize_specialized_instruction_addl (struct jitter_parameter ** const ps,
4933 bool enable_fast_literals)
4934 __attribute__ ((pure));
4935 inline static enum pvm_specialized_instruction_opcode
4936 pvm_recognize_specialized_instruction_addlu (struct jitter_parameter ** const ps,
4937 bool enable_fast_literals)
4938 __attribute__ ((pure));
4939 inline static enum pvm_specialized_instruction_opcode
4940 pvm_recognize_specialized_instruction_ains (struct jitter_parameter ** const ps,
4941 bool enable_fast_literals)
4942 __attribute__ ((pure));
4943 inline static enum pvm_specialized_instruction_opcode
4944 pvm_recognize_specialized_instruction_and (struct jitter_parameter ** const ps,
4945 bool enable_fast_literals)
4946 __attribute__ ((pure));
4947 inline static enum pvm_specialized_instruction_opcode
4948 pvm_recognize_specialized_instruction_aref (struct jitter_parameter ** const ps,
4949 bool enable_fast_literals)
4950 __attribute__ ((pure));
4951 inline static enum pvm_specialized_instruction_opcode
4952 pvm_recognize_specialized_instruction_arefo (struct jitter_parameter ** const ps,
4953 bool enable_fast_literals)
4954 __attribute__ ((pure));
4955 inline static enum pvm_specialized_instruction_opcode
4956 pvm_recognize_specialized_instruction_arem (struct jitter_parameter ** const ps,
4957 bool enable_fast_literals)
4958 __attribute__ ((pure));
4959 inline static enum pvm_specialized_instruction_opcode
4960 pvm_recognize_specialized_instruction_aset (struct jitter_parameter ** const ps,
4961 bool enable_fast_literals)
4962 __attribute__ ((pure));
4963 inline static enum pvm_specialized_instruction_opcode
4964 pvm_recognize_specialized_instruction_asettb (struct jitter_parameter ** const ps,
4965 bool enable_fast_literals)
4966 __attribute__ ((pure));
4967 inline static enum pvm_specialized_instruction_opcode
4968 pvm_recognize_specialized_instruction_atr (struct jitter_parameter ** const ps,
4969 bool enable_fast_literals)
4970 __attribute__ ((pure));
4971 inline static enum pvm_specialized_instruction_opcode
4972 pvm_recognize_specialized_instruction_ba (struct jitter_parameter ** const ps,
4973 bool enable_fast_literals)
4974 __attribute__ ((pure));
4975 inline static enum pvm_specialized_instruction_opcode
4976 pvm_recognize_specialized_instruction_ba__fR (struct jitter_parameter ** const ps,
4977 bool enable_fast_literals)
4978 __attribute__ ((pure));
4979 inline static enum pvm_specialized_instruction_opcode
4980 pvm_recognize_specialized_instruction_bandi (struct jitter_parameter ** const ps,
4981 bool enable_fast_literals)
4982 __attribute__ ((pure));
4983 inline static enum pvm_specialized_instruction_opcode
4984 pvm_recognize_specialized_instruction_bandiu (struct jitter_parameter ** const ps,
4985 bool enable_fast_literals)
4986 __attribute__ ((pure));
4987 inline static enum pvm_specialized_instruction_opcode
4988 pvm_recognize_specialized_instruction_bandl (struct jitter_parameter ** const ps,
4989 bool enable_fast_literals)
4990 __attribute__ ((pure));
4991 inline static enum pvm_specialized_instruction_opcode
4992 pvm_recognize_specialized_instruction_bandlu (struct jitter_parameter ** const ps,
4993 bool enable_fast_literals)
4994 __attribute__ ((pure));
4995 inline static enum pvm_specialized_instruction_opcode
4996 pvm_recognize_specialized_instruction_beghl (struct jitter_parameter ** const ps,
4997 bool enable_fast_literals)
4998 __attribute__ ((pure));
4999 inline static enum pvm_specialized_instruction_opcode
5000 pvm_recognize_specialized_instruction_begsc (struct jitter_parameter ** const ps,
5001 bool enable_fast_literals)
5002 __attribute__ ((pure));
5003 inline static enum pvm_specialized_instruction_opcode
5004 pvm_recognize_specialized_instruction_bn (struct jitter_parameter ** const ps,
5005 bool enable_fast_literals)
5006 __attribute__ ((pure));
5007 inline static enum pvm_specialized_instruction_opcode
5008 pvm_recognize_specialized_instruction_bn__fR (struct jitter_parameter ** const ps,
5009 bool enable_fast_literals)
5010 __attribute__ ((pure));
5011 inline static enum pvm_specialized_instruction_opcode
5012 pvm_recognize_specialized_instruction_bnn (struct jitter_parameter ** const ps,
5013 bool enable_fast_literals)
5014 __attribute__ ((pure));
5015 inline static enum pvm_specialized_instruction_opcode
5016 pvm_recognize_specialized_instruction_bnn__fR (struct jitter_parameter ** const ps,
5017 bool enable_fast_literals)
5018 __attribute__ ((pure));
5019 inline static enum pvm_specialized_instruction_opcode
5020 pvm_recognize_specialized_instruction_bnoti (struct jitter_parameter ** const ps,
5021 bool enable_fast_literals)
5022 __attribute__ ((pure));
5023 inline static enum pvm_specialized_instruction_opcode
5024 pvm_recognize_specialized_instruction_bnotiu (struct jitter_parameter ** const ps,
5025 bool enable_fast_literals)
5026 __attribute__ ((pure));
5027 inline static enum pvm_specialized_instruction_opcode
5028 pvm_recognize_specialized_instruction_bnotl (struct jitter_parameter ** const ps,
5029 bool enable_fast_literals)
5030 __attribute__ ((pure));
5031 inline static enum pvm_specialized_instruction_opcode
5032 pvm_recognize_specialized_instruction_bnotlu (struct jitter_parameter ** const ps,
5033 bool enable_fast_literals)
5034 __attribute__ ((pure));
5035 inline static enum pvm_specialized_instruction_opcode
5036 pvm_recognize_specialized_instruction_bnzi (struct jitter_parameter ** const ps,
5037 bool enable_fast_literals)
5038 __attribute__ ((pure));
5039 inline static enum pvm_specialized_instruction_opcode
5040 pvm_recognize_specialized_instruction_bnzi__fR (struct jitter_parameter ** const ps,
5041 bool enable_fast_literals)
5042 __attribute__ ((pure));
5043 inline static enum pvm_specialized_instruction_opcode
5044 pvm_recognize_specialized_instruction_bnziu (struct jitter_parameter ** const ps,
5045 bool enable_fast_literals)
5046 __attribute__ ((pure));
5047 inline static enum pvm_specialized_instruction_opcode
5048 pvm_recognize_specialized_instruction_bnziu__fR (struct jitter_parameter ** const ps,
5049 bool enable_fast_literals)
5050 __attribute__ ((pure));
5051 inline static enum pvm_specialized_instruction_opcode
5052 pvm_recognize_specialized_instruction_bnzl (struct jitter_parameter ** const ps,
5053 bool enable_fast_literals)
5054 __attribute__ ((pure));
5055 inline static enum pvm_specialized_instruction_opcode
5056 pvm_recognize_specialized_instruction_bnzl__fR (struct jitter_parameter ** const ps,
5057 bool enable_fast_literals)
5058 __attribute__ ((pure));
5059 inline static enum pvm_specialized_instruction_opcode
5060 pvm_recognize_specialized_instruction_bnzlu (struct jitter_parameter ** const ps,
5061 bool enable_fast_literals)
5062 __attribute__ ((pure));
5063 inline static enum pvm_specialized_instruction_opcode
5064 pvm_recognize_specialized_instruction_bnzlu__fR (struct jitter_parameter ** const ps,
5065 bool enable_fast_literals)
5066 __attribute__ ((pure));
5067 inline static enum pvm_specialized_instruction_opcode
5068 pvm_recognize_specialized_instruction_bori (struct jitter_parameter ** const ps,
5069 bool enable_fast_literals)
5070 __attribute__ ((pure));
5071 inline static enum pvm_specialized_instruction_opcode
5072 pvm_recognize_specialized_instruction_boriu (struct jitter_parameter ** const ps,
5073 bool enable_fast_literals)
5074 __attribute__ ((pure));
5075 inline static enum pvm_specialized_instruction_opcode
5076 pvm_recognize_specialized_instruction_borl (struct jitter_parameter ** const ps,
5077 bool enable_fast_literals)
5078 __attribute__ ((pure));
5079 inline static enum pvm_specialized_instruction_opcode
5080 pvm_recognize_specialized_instruction_borlu (struct jitter_parameter ** const ps,
5081 bool enable_fast_literals)
5082 __attribute__ ((pure));
5083 inline static enum pvm_specialized_instruction_opcode
5084 pvm_recognize_specialized_instruction_bsli (struct jitter_parameter ** const ps,
5085 bool enable_fast_literals)
5086 __attribute__ ((pure));
5087 inline static enum pvm_specialized_instruction_opcode
5088 pvm_recognize_specialized_instruction_bsliu (struct jitter_parameter ** const ps,
5089 bool enable_fast_literals)
5090 __attribute__ ((pure));
5091 inline static enum pvm_specialized_instruction_opcode
5092 pvm_recognize_specialized_instruction_bsll (struct jitter_parameter ** const ps,
5093 bool enable_fast_literals)
5094 __attribute__ ((pure));
5095 inline static enum pvm_specialized_instruction_opcode
5096 pvm_recognize_specialized_instruction_bsllu (struct jitter_parameter ** const ps,
5097 bool enable_fast_literals)
5098 __attribute__ ((pure));
5099 inline static enum pvm_specialized_instruction_opcode
5100 pvm_recognize_specialized_instruction_bsri (struct jitter_parameter ** const ps,
5101 bool enable_fast_literals)
5102 __attribute__ ((pure));
5103 inline static enum pvm_specialized_instruction_opcode
5104 pvm_recognize_specialized_instruction_bsriu (struct jitter_parameter ** const ps,
5105 bool enable_fast_literals)
5106 __attribute__ ((pure));
5107 inline static enum pvm_specialized_instruction_opcode
5108 pvm_recognize_specialized_instruction_bsrl (struct jitter_parameter ** const ps,
5109 bool enable_fast_literals)
5110 __attribute__ ((pure));
5111 inline static enum pvm_specialized_instruction_opcode
5112 pvm_recognize_specialized_instruction_bsrlu (struct jitter_parameter ** const ps,
5113 bool enable_fast_literals)
5114 __attribute__ ((pure));
5115 inline static enum pvm_specialized_instruction_opcode
5116 pvm_recognize_specialized_instruction_bxori (struct jitter_parameter ** const ps,
5117 bool enable_fast_literals)
5118 __attribute__ ((pure));
5119 inline static enum pvm_specialized_instruction_opcode
5120 pvm_recognize_specialized_instruction_bxoriu (struct jitter_parameter ** const ps,
5121 bool enable_fast_literals)
5122 __attribute__ ((pure));
5123 inline static enum pvm_specialized_instruction_opcode
5124 pvm_recognize_specialized_instruction_bxorl (struct jitter_parameter ** const ps,
5125 bool enable_fast_literals)
5126 __attribute__ ((pure));
5127 inline static enum pvm_specialized_instruction_opcode
5128 pvm_recognize_specialized_instruction_bxorlu (struct jitter_parameter ** const ps,
5129 bool enable_fast_literals)
5130 __attribute__ ((pure));
5131 inline static enum pvm_specialized_instruction_opcode
5132 pvm_recognize_specialized_instruction_bzi (struct jitter_parameter ** const ps,
5133 bool enable_fast_literals)
5134 __attribute__ ((pure));
5135 inline static enum pvm_specialized_instruction_opcode
5136 pvm_recognize_specialized_instruction_bzi__fR (struct jitter_parameter ** const ps,
5137 bool enable_fast_literals)
5138 __attribute__ ((pure));
5139 inline static enum pvm_specialized_instruction_opcode
5140 pvm_recognize_specialized_instruction_bziu (struct jitter_parameter ** const ps,
5141 bool enable_fast_literals)
5142 __attribute__ ((pure));
5143 inline static enum pvm_specialized_instruction_opcode
5144 pvm_recognize_specialized_instruction_bziu__fR (struct jitter_parameter ** const ps,
5145 bool enable_fast_literals)
5146 __attribute__ ((pure));
5147 inline static enum pvm_specialized_instruction_opcode
5148 pvm_recognize_specialized_instruction_bzl (struct jitter_parameter ** const ps,
5149 bool enable_fast_literals)
5150 __attribute__ ((pure));
5151 inline static enum pvm_specialized_instruction_opcode
5152 pvm_recognize_specialized_instruction_bzl__fR (struct jitter_parameter ** const ps,
5153 bool enable_fast_literals)
5154 __attribute__ ((pure));
5155 inline static enum pvm_specialized_instruction_opcode
5156 pvm_recognize_specialized_instruction_bzlu (struct jitter_parameter ** const ps,
5157 bool enable_fast_literals)
5158 __attribute__ ((pure));
5159 inline static enum pvm_specialized_instruction_opcode
5160 pvm_recognize_specialized_instruction_bzlu__fR (struct jitter_parameter ** const ps,
5161 bool enable_fast_literals)
5162 __attribute__ ((pure));
5163 inline static enum pvm_specialized_instruction_opcode
5164 pvm_recognize_specialized_instruction_call (struct jitter_parameter ** const ps,
5165 bool enable_fast_literals)
5166 __attribute__ ((pure));
5167 inline static enum pvm_specialized_instruction_opcode
5168 pvm_recognize_specialized_instruction_canary (struct jitter_parameter ** const ps,
5169 bool enable_fast_literals)
5170 __attribute__ ((pure));
5171 inline static enum pvm_specialized_instruction_opcode
5172 pvm_recognize_specialized_instruction_close (struct jitter_parameter ** const ps,
5173 bool enable_fast_literals)
5174 __attribute__ ((pure));
5175 inline static enum pvm_specialized_instruction_opcode
5176 pvm_recognize_specialized_instruction_ctos (struct jitter_parameter ** const ps,
5177 bool enable_fast_literals)
5178 __attribute__ ((pure));
5179 inline static enum pvm_specialized_instruction_opcode
5180 pvm_recognize_specialized_instruction_disas (struct jitter_parameter ** const ps,
5181 bool enable_fast_literals)
5182 __attribute__ ((pure));
5183 inline static enum pvm_specialized_instruction_opcode
5184 pvm_recognize_specialized_instruction_divi (struct jitter_parameter ** const ps,
5185 bool enable_fast_literals)
5186 __attribute__ ((pure));
5187 inline static enum pvm_specialized_instruction_opcode
5188 pvm_recognize_specialized_instruction_diviu (struct jitter_parameter ** const ps,
5189 bool enable_fast_literals)
5190 __attribute__ ((pure));
5191 inline static enum pvm_specialized_instruction_opcode
5192 pvm_recognize_specialized_instruction_divl (struct jitter_parameter ** const ps,
5193 bool enable_fast_literals)
5194 __attribute__ ((pure));
5195 inline static enum pvm_specialized_instruction_opcode
5196 pvm_recognize_specialized_instruction_divlu (struct jitter_parameter ** const ps,
5197 bool enable_fast_literals)
5198 __attribute__ ((pure));
5199 inline static enum pvm_specialized_instruction_opcode
5200 pvm_recognize_specialized_instruction_drop (struct jitter_parameter ** const ps,
5201 bool enable_fast_literals)
5202 __attribute__ ((pure));
5203 inline static enum pvm_specialized_instruction_opcode
5204 pvm_recognize_specialized_instruction_drop2 (struct jitter_parameter ** const ps,
5205 bool enable_fast_literals)
5206 __attribute__ ((pure));
5207 inline static enum pvm_specialized_instruction_opcode
5208 pvm_recognize_specialized_instruction_drop3 (struct jitter_parameter ** const ps,
5209 bool enable_fast_literals)
5210 __attribute__ ((pure));
5211 inline static enum pvm_specialized_instruction_opcode
5212 pvm_recognize_specialized_instruction_drop4 (struct jitter_parameter ** const ps,
5213 bool enable_fast_literals)
5214 __attribute__ ((pure));
5215 inline static enum pvm_specialized_instruction_opcode
5216 pvm_recognize_specialized_instruction_duc (struct jitter_parameter ** const ps,
5217 bool enable_fast_literals)
5218 __attribute__ ((pure));
5219 inline static enum pvm_specialized_instruction_opcode
5220 pvm_recognize_specialized_instruction_dup (struct jitter_parameter ** const ps,
5221 bool enable_fast_literals)
5222 __attribute__ ((pure));
5223 inline static enum pvm_specialized_instruction_opcode
5224 pvm_recognize_specialized_instruction_endhl (struct jitter_parameter ** const ps,
5225 bool enable_fast_literals)
5226 __attribute__ ((pure));
5227 inline static enum pvm_specialized_instruction_opcode
5228 pvm_recognize_specialized_instruction_endsc (struct jitter_parameter ** const ps,
5229 bool enable_fast_literals)
5230 __attribute__ ((pure));
5231 inline static enum pvm_specialized_instruction_opcode
5232 pvm_recognize_specialized_instruction_eqi (struct jitter_parameter ** const ps,
5233 bool enable_fast_literals)
5234 __attribute__ ((pure));
5235 inline static enum pvm_specialized_instruction_opcode
5236 pvm_recognize_specialized_instruction_eqiu (struct jitter_parameter ** const ps,
5237 bool enable_fast_literals)
5238 __attribute__ ((pure));
5239 inline static enum pvm_specialized_instruction_opcode
5240 pvm_recognize_specialized_instruction_eql (struct jitter_parameter ** const ps,
5241 bool enable_fast_literals)
5242 __attribute__ ((pure));
5243 inline static enum pvm_specialized_instruction_opcode
5244 pvm_recognize_specialized_instruction_eqlu (struct jitter_parameter ** const ps,
5245 bool enable_fast_literals)
5246 __attribute__ ((pure));
5247 inline static enum pvm_specialized_instruction_opcode
5248 pvm_recognize_specialized_instruction_eqs (struct jitter_parameter ** const ps,
5249 bool enable_fast_literals)
5250 __attribute__ ((pure));
5251 inline static enum pvm_specialized_instruction_opcode
5252 pvm_recognize_specialized_instruction_exit (struct jitter_parameter ** const ps,
5253 bool enable_fast_literals)
5254 __attribute__ ((pure));
5255 inline static enum pvm_specialized_instruction_opcode
5256 pvm_recognize_specialized_instruction_exitvm (struct jitter_parameter ** const ps,
5257 bool enable_fast_literals)
5258 __attribute__ ((pure));
5259 inline static enum pvm_specialized_instruction_opcode
5260 pvm_recognize_specialized_instruction_flush (struct jitter_parameter ** const ps,
5261 bool enable_fast_literals)
5262 __attribute__ ((pure));
5263 inline static enum pvm_specialized_instruction_opcode
5264 pvm_recognize_specialized_instruction_fromr (struct jitter_parameter ** const ps,
5265 bool enable_fast_literals)
5266 __attribute__ ((pure));
5267 inline static enum pvm_specialized_instruction_opcode
5268 pvm_recognize_specialized_instruction_gei (struct jitter_parameter ** const ps,
5269 bool enable_fast_literals)
5270 __attribute__ ((pure));
5271 inline static enum pvm_specialized_instruction_opcode
5272 pvm_recognize_specialized_instruction_geiu (struct jitter_parameter ** const ps,
5273 bool enable_fast_literals)
5274 __attribute__ ((pure));
5275 inline static enum pvm_specialized_instruction_opcode
5276 pvm_recognize_specialized_instruction_gel (struct jitter_parameter ** const ps,
5277 bool enable_fast_literals)
5278 __attribute__ ((pure));
5279 inline static enum pvm_specialized_instruction_opcode
5280 pvm_recognize_specialized_instruction_gelu (struct jitter_parameter ** const ps,
5281 bool enable_fast_literals)
5282 __attribute__ ((pure));
5283 inline static enum pvm_specialized_instruction_opcode
5284 pvm_recognize_specialized_instruction_ges (struct jitter_parameter ** const ps,
5285 bool enable_fast_literals)
5286 __attribute__ ((pure));
5287 inline static enum pvm_specialized_instruction_opcode
5288 pvm_recognize_specialized_instruction_getenv (struct jitter_parameter ** const ps,
5289 bool enable_fast_literals)
5290 __attribute__ ((pure));
5291 inline static enum pvm_specialized_instruction_opcode
5292 pvm_recognize_specialized_instruction_gti (struct jitter_parameter ** const ps,
5293 bool enable_fast_literals)
5294 __attribute__ ((pure));
5295 inline static enum pvm_specialized_instruction_opcode
5296 pvm_recognize_specialized_instruction_gtiu (struct jitter_parameter ** const ps,
5297 bool enable_fast_literals)
5298 __attribute__ ((pure));
5299 inline static enum pvm_specialized_instruction_opcode
5300 pvm_recognize_specialized_instruction_gtl (struct jitter_parameter ** const ps,
5301 bool enable_fast_literals)
5302 __attribute__ ((pure));
5303 inline static enum pvm_specialized_instruction_opcode
5304 pvm_recognize_specialized_instruction_gtlu (struct jitter_parameter ** const ps,
5305 bool enable_fast_literals)
5306 __attribute__ ((pure));
5307 inline static enum pvm_specialized_instruction_opcode
5308 pvm_recognize_specialized_instruction_gts (struct jitter_parameter ** const ps,
5309 bool enable_fast_literals)
5310 __attribute__ ((pure));
5311 inline static enum pvm_specialized_instruction_opcode
5312 pvm_recognize_specialized_instruction_indent (struct jitter_parameter ** const ps,
5313 bool enable_fast_literals)
5314 __attribute__ ((pure));
5315 inline static enum pvm_specialized_instruction_opcode
5316 pvm_recognize_specialized_instruction_iogetb (struct jitter_parameter ** const ps,
5317 bool enable_fast_literals)
5318 __attribute__ ((pure));
5319 inline static enum pvm_specialized_instruction_opcode
5320 pvm_recognize_specialized_instruction_iosetb (struct jitter_parameter ** const ps,
5321 bool enable_fast_literals)
5322 __attribute__ ((pure));
5323 inline static enum pvm_specialized_instruction_opcode
5324 pvm_recognize_specialized_instruction_iosize (struct jitter_parameter ** const ps,
5325 bool enable_fast_literals)
5326 __attribute__ ((pure));
5327 inline static enum pvm_specialized_instruction_opcode
5328 pvm_recognize_specialized_instruction_isa (struct jitter_parameter ** const ps,
5329 bool enable_fast_literals)
5330 __attribute__ ((pure));
5331 inline static enum pvm_specialized_instruction_opcode
5332 pvm_recognize_specialized_instruction_itoi (struct jitter_parameter ** const ps,
5333 bool enable_fast_literals)
5334 __attribute__ ((pure));
5335 inline static enum pvm_specialized_instruction_opcode
5336 pvm_recognize_specialized_instruction_itoi__nR (struct jitter_parameter ** const ps,
5337 bool enable_fast_literals)
5338 __attribute__ ((pure));
5339 inline static enum pvm_specialized_instruction_opcode
5340 pvm_recognize_specialized_instruction_itoiu (struct jitter_parameter ** const ps,
5341 bool enable_fast_literals)
5342 __attribute__ ((pure));
5343 inline static enum pvm_specialized_instruction_opcode
5344 pvm_recognize_specialized_instruction_itoiu__nR (struct jitter_parameter ** const ps,
5345 bool enable_fast_literals)
5346 __attribute__ ((pure));
5347 inline static enum pvm_specialized_instruction_opcode
5348 pvm_recognize_specialized_instruction_itol (struct jitter_parameter ** const ps,
5349 bool enable_fast_literals)
5350 __attribute__ ((pure));
5351 inline static enum pvm_specialized_instruction_opcode
5352 pvm_recognize_specialized_instruction_itol__nR (struct jitter_parameter ** const ps,
5353 bool enable_fast_literals)
5354 __attribute__ ((pure));
5355 inline static enum pvm_specialized_instruction_opcode
5356 pvm_recognize_specialized_instruction_itolu (struct jitter_parameter ** const ps,
5357 bool enable_fast_literals)
5358 __attribute__ ((pure));
5359 inline static enum pvm_specialized_instruction_opcode
5360 pvm_recognize_specialized_instruction_itolu__nR (struct jitter_parameter ** const ps,
5361 bool enable_fast_literals)
5362 __attribute__ ((pure));
5363 inline static enum pvm_specialized_instruction_opcode
5364 pvm_recognize_specialized_instruction_iutoi (struct jitter_parameter ** const ps,
5365 bool enable_fast_literals)
5366 __attribute__ ((pure));
5367 inline static enum pvm_specialized_instruction_opcode
5368 pvm_recognize_specialized_instruction_iutoi__nR (struct jitter_parameter ** const ps,
5369 bool enable_fast_literals)
5370 __attribute__ ((pure));
5371 inline static enum pvm_specialized_instruction_opcode
5372 pvm_recognize_specialized_instruction_iutoiu (struct jitter_parameter ** const ps,
5373 bool enable_fast_literals)
5374 __attribute__ ((pure));
5375 inline static enum pvm_specialized_instruction_opcode
5376 pvm_recognize_specialized_instruction_iutoiu__nR (struct jitter_parameter ** const ps,
5377 bool enable_fast_literals)
5378 __attribute__ ((pure));
5379 inline static enum pvm_specialized_instruction_opcode
5380 pvm_recognize_specialized_instruction_iutol (struct jitter_parameter ** const ps,
5381 bool enable_fast_literals)
5382 __attribute__ ((pure));
5383 inline static enum pvm_specialized_instruction_opcode
5384 pvm_recognize_specialized_instruction_iutol__nR (struct jitter_parameter ** const ps,
5385 bool enable_fast_literals)
5386 __attribute__ ((pure));
5387 inline static enum pvm_specialized_instruction_opcode
5388 pvm_recognize_specialized_instruction_iutolu (struct jitter_parameter ** const ps,
5389 bool enable_fast_literals)
5390 __attribute__ ((pure));
5391 inline static enum pvm_specialized_instruction_opcode
5392 pvm_recognize_specialized_instruction_iutolu__nR (struct jitter_parameter ** const ps,
5393 bool enable_fast_literals)
5394 __attribute__ ((pure));
5395 inline static enum pvm_specialized_instruction_opcode
5396 pvm_recognize_specialized_instruction_lei (struct jitter_parameter ** const ps,
5397 bool enable_fast_literals)
5398 __attribute__ ((pure));
5399 inline static enum pvm_specialized_instruction_opcode
5400 pvm_recognize_specialized_instruction_leiu (struct jitter_parameter ** const ps,
5401 bool enable_fast_literals)
5402 __attribute__ ((pure));
5403 inline static enum pvm_specialized_instruction_opcode
5404 pvm_recognize_specialized_instruction_lel (struct jitter_parameter ** const ps,
5405 bool enable_fast_literals)
5406 __attribute__ ((pure));
5407 inline static enum pvm_specialized_instruction_opcode
5408 pvm_recognize_specialized_instruction_lelu (struct jitter_parameter ** const ps,
5409 bool enable_fast_literals)
5410 __attribute__ ((pure));
5411 inline static enum pvm_specialized_instruction_opcode
5412 pvm_recognize_specialized_instruction_les (struct jitter_parameter ** const ps,
5413 bool enable_fast_literals)
5414 __attribute__ ((pure));
5415 inline static enum pvm_specialized_instruction_opcode
5416 pvm_recognize_specialized_instruction_lti (struct jitter_parameter ** const ps,
5417 bool enable_fast_literals)
5418 __attribute__ ((pure));
5419 inline static enum pvm_specialized_instruction_opcode
5420 pvm_recognize_specialized_instruction_ltiu (struct jitter_parameter ** const ps,
5421 bool enable_fast_literals)
5422 __attribute__ ((pure));
5423 inline static enum pvm_specialized_instruction_opcode
5424 pvm_recognize_specialized_instruction_ltl (struct jitter_parameter ** const ps,
5425 bool enable_fast_literals)
5426 __attribute__ ((pure));
5427 inline static enum pvm_specialized_instruction_opcode
5428 pvm_recognize_specialized_instruction_ltlu (struct jitter_parameter ** const ps,
5429 bool enable_fast_literals)
5430 __attribute__ ((pure));
5431 inline static enum pvm_specialized_instruction_opcode
5432 pvm_recognize_specialized_instruction_ltoi (struct jitter_parameter ** const ps,
5433 bool enable_fast_literals)
5434 __attribute__ ((pure));
5435 inline static enum pvm_specialized_instruction_opcode
5436 pvm_recognize_specialized_instruction_ltoi__nR (struct jitter_parameter ** const ps,
5437 bool enable_fast_literals)
5438 __attribute__ ((pure));
5439 inline static enum pvm_specialized_instruction_opcode
5440 pvm_recognize_specialized_instruction_ltoiu (struct jitter_parameter ** const ps,
5441 bool enable_fast_literals)
5442 __attribute__ ((pure));
5443 inline static enum pvm_specialized_instruction_opcode
5444 pvm_recognize_specialized_instruction_ltoiu__nR (struct jitter_parameter ** const ps,
5445 bool enable_fast_literals)
5446 __attribute__ ((pure));
5447 inline static enum pvm_specialized_instruction_opcode
5448 pvm_recognize_specialized_instruction_ltol (struct jitter_parameter ** const ps,
5449 bool enable_fast_literals)
5450 __attribute__ ((pure));
5451 inline static enum pvm_specialized_instruction_opcode
5452 pvm_recognize_specialized_instruction_ltol__nR (struct jitter_parameter ** const ps,
5453 bool enable_fast_literals)
5454 __attribute__ ((pure));
5455 inline static enum pvm_specialized_instruction_opcode
5456 pvm_recognize_specialized_instruction_ltolu (struct jitter_parameter ** const ps,
5457 bool enable_fast_literals)
5458 __attribute__ ((pure));
5459 inline static enum pvm_specialized_instruction_opcode
5460 pvm_recognize_specialized_instruction_ltolu__nR (struct jitter_parameter ** const ps,
5461 bool enable_fast_literals)
5462 __attribute__ ((pure));
5463 inline static enum pvm_specialized_instruction_opcode
5464 pvm_recognize_specialized_instruction_lts (struct jitter_parameter ** const ps,
5465 bool enable_fast_literals)
5466 __attribute__ ((pure));
5467 inline static enum pvm_specialized_instruction_opcode
5468 pvm_recognize_specialized_instruction_lutoi (struct jitter_parameter ** const ps,
5469 bool enable_fast_literals)
5470 __attribute__ ((pure));
5471 inline static enum pvm_specialized_instruction_opcode
5472 pvm_recognize_specialized_instruction_lutoi__nR (struct jitter_parameter ** const ps,
5473 bool enable_fast_literals)
5474 __attribute__ ((pure));
5475 inline static enum pvm_specialized_instruction_opcode
5476 pvm_recognize_specialized_instruction_lutoiu (struct jitter_parameter ** const ps,
5477 bool enable_fast_literals)
5478 __attribute__ ((pure));
5479 inline static enum pvm_specialized_instruction_opcode
5480 pvm_recognize_specialized_instruction_lutoiu__nR (struct jitter_parameter ** const ps,
5481 bool enable_fast_literals)
5482 __attribute__ ((pure));
5483 inline static enum pvm_specialized_instruction_opcode
5484 pvm_recognize_specialized_instruction_lutol (struct jitter_parameter ** const ps,
5485 bool enable_fast_literals)
5486 __attribute__ ((pure));
5487 inline static enum pvm_specialized_instruction_opcode
5488 pvm_recognize_specialized_instruction_lutol__nR (struct jitter_parameter ** const ps,
5489 bool enable_fast_literals)
5490 __attribute__ ((pure));
5491 inline static enum pvm_specialized_instruction_opcode
5492 pvm_recognize_specialized_instruction_lutolu (struct jitter_parameter ** const ps,
5493 bool enable_fast_literals)
5494 __attribute__ ((pure));
5495 inline static enum pvm_specialized_instruction_opcode
5496 pvm_recognize_specialized_instruction_lutolu__nR (struct jitter_parameter ** const ps,
5497 bool enable_fast_literals)
5498 __attribute__ ((pure));
5499 inline static enum pvm_specialized_instruction_opcode
5500 pvm_recognize_specialized_instruction_map (struct jitter_parameter ** const ps,
5501 bool enable_fast_literals)
5502 __attribute__ ((pure));
5503 inline static enum pvm_specialized_instruction_opcode
5504 pvm_recognize_specialized_instruction_mgetios (struct jitter_parameter ** const ps,
5505 bool enable_fast_literals)
5506 __attribute__ ((pure));
5507 inline static enum pvm_specialized_instruction_opcode
5508 pvm_recognize_specialized_instruction_mgetm (struct jitter_parameter ** const ps,
5509 bool enable_fast_literals)
5510 __attribute__ ((pure));
5511 inline static enum pvm_specialized_instruction_opcode
5512 pvm_recognize_specialized_instruction_mgeto (struct jitter_parameter ** const ps,
5513 bool enable_fast_literals)
5514 __attribute__ ((pure));
5515 inline static enum pvm_specialized_instruction_opcode
5516 pvm_recognize_specialized_instruction_mgets (struct jitter_parameter ** const ps,
5517 bool enable_fast_literals)
5518 __attribute__ ((pure));
5519 inline static enum pvm_specialized_instruction_opcode
5520 pvm_recognize_specialized_instruction_mgetsel (struct jitter_parameter ** const ps,
5521 bool enable_fast_literals)
5522 __attribute__ ((pure));
5523 inline static enum pvm_specialized_instruction_opcode
5524 pvm_recognize_specialized_instruction_mgetsiz (struct jitter_parameter ** const ps,
5525 bool enable_fast_literals)
5526 __attribute__ ((pure));
5527 inline static enum pvm_specialized_instruction_opcode
5528 pvm_recognize_specialized_instruction_mgetw (struct jitter_parameter ** const ps,
5529 bool enable_fast_literals)
5530 __attribute__ ((pure));
5531 inline static enum pvm_specialized_instruction_opcode
5532 pvm_recognize_specialized_instruction_mka (struct jitter_parameter ** const ps,
5533 bool enable_fast_literals)
5534 __attribute__ ((pure));
5535 inline static enum pvm_specialized_instruction_opcode
5536 pvm_recognize_specialized_instruction_mko (struct jitter_parameter ** const ps,
5537 bool enable_fast_literals)
5538 __attribute__ ((pure));
5539 inline static enum pvm_specialized_instruction_opcode
5540 pvm_recognize_specialized_instruction_mksct (struct jitter_parameter ** const ps,
5541 bool enable_fast_literals)
5542 __attribute__ ((pure));
5543 inline static enum pvm_specialized_instruction_opcode
5544 pvm_recognize_specialized_instruction_mktya (struct jitter_parameter ** const ps,
5545 bool enable_fast_literals)
5546 __attribute__ ((pure));
5547 inline static enum pvm_specialized_instruction_opcode
5548 pvm_recognize_specialized_instruction_mktyany (struct jitter_parameter ** const ps,
5549 bool enable_fast_literals)
5550 __attribute__ ((pure));
5551 inline static enum pvm_specialized_instruction_opcode
5552 pvm_recognize_specialized_instruction_mktyc (struct jitter_parameter ** const ps,
5553 bool enable_fast_literals)
5554 __attribute__ ((pure));
5555 inline static enum pvm_specialized_instruction_opcode
5556 pvm_recognize_specialized_instruction_mktyi (struct jitter_parameter ** const ps,
5557 bool enable_fast_literals)
5558 __attribute__ ((pure));
5559 inline static enum pvm_specialized_instruction_opcode
5560 pvm_recognize_specialized_instruction_mktyo (struct jitter_parameter ** const ps,
5561 bool enable_fast_literals)
5562 __attribute__ ((pure));
5563 inline static enum pvm_specialized_instruction_opcode
5564 pvm_recognize_specialized_instruction_mktys (struct jitter_parameter ** const ps,
5565 bool enable_fast_literals)
5566 __attribute__ ((pure));
5567 inline static enum pvm_specialized_instruction_opcode
5568 pvm_recognize_specialized_instruction_mktysct (struct jitter_parameter ** const ps,
5569 bool enable_fast_literals)
5570 __attribute__ ((pure));
5571 inline static enum pvm_specialized_instruction_opcode
5572 pvm_recognize_specialized_instruction_mktyv (struct jitter_parameter ** const ps,
5573 bool enable_fast_literals)
5574 __attribute__ ((pure));
5575 inline static enum pvm_specialized_instruction_opcode
5576 pvm_recognize_specialized_instruction_mm (struct jitter_parameter ** const ps,
5577 bool enable_fast_literals)
5578 __attribute__ ((pure));
5579 inline static enum pvm_specialized_instruction_opcode
5580 pvm_recognize_specialized_instruction_modi (struct jitter_parameter ** const ps,
5581 bool enable_fast_literals)
5582 __attribute__ ((pure));
5583 inline static enum pvm_specialized_instruction_opcode
5584 pvm_recognize_specialized_instruction_modiu (struct jitter_parameter ** const ps,
5585 bool enable_fast_literals)
5586 __attribute__ ((pure));
5587 inline static enum pvm_specialized_instruction_opcode
5588 pvm_recognize_specialized_instruction_modl (struct jitter_parameter ** const ps,
5589 bool enable_fast_literals)
5590 __attribute__ ((pure));
5591 inline static enum pvm_specialized_instruction_opcode
5592 pvm_recognize_specialized_instruction_modlu (struct jitter_parameter ** const ps,
5593 bool enable_fast_literals)
5594 __attribute__ ((pure));
5595 inline static enum pvm_specialized_instruction_opcode
5596 pvm_recognize_specialized_instruction_msetios (struct jitter_parameter ** const ps,
5597 bool enable_fast_literals)
5598 __attribute__ ((pure));
5599 inline static enum pvm_specialized_instruction_opcode
5600 pvm_recognize_specialized_instruction_msetm (struct jitter_parameter ** const ps,
5601 bool enable_fast_literals)
5602 __attribute__ ((pure));
5603 inline static enum pvm_specialized_instruction_opcode
5604 pvm_recognize_specialized_instruction_mseto (struct jitter_parameter ** const ps,
5605 bool enable_fast_literals)
5606 __attribute__ ((pure));
5607 inline static enum pvm_specialized_instruction_opcode
5608 pvm_recognize_specialized_instruction_msets (struct jitter_parameter ** const ps,
5609 bool enable_fast_literals)
5610 __attribute__ ((pure));
5611 inline static enum pvm_specialized_instruction_opcode
5612 pvm_recognize_specialized_instruction_msetsel (struct jitter_parameter ** const ps,
5613 bool enable_fast_literals)
5614 __attribute__ ((pure));
5615 inline static enum pvm_specialized_instruction_opcode
5616 pvm_recognize_specialized_instruction_msetsiz (struct jitter_parameter ** const ps,
5617 bool enable_fast_literals)
5618 __attribute__ ((pure));
5619 inline static enum pvm_specialized_instruction_opcode
5620 pvm_recognize_specialized_instruction_msetw (struct jitter_parameter ** const ps,
5621 bool enable_fast_literals)
5622 __attribute__ ((pure));
5623 inline static enum pvm_specialized_instruction_opcode
5624 pvm_recognize_specialized_instruction_muli (struct jitter_parameter ** const ps,
5625 bool enable_fast_literals)
5626 __attribute__ ((pure));
5627 inline static enum pvm_specialized_instruction_opcode
5628 pvm_recognize_specialized_instruction_muliu (struct jitter_parameter ** const ps,
5629 bool enable_fast_literals)
5630 __attribute__ ((pure));
5631 inline static enum pvm_specialized_instruction_opcode
5632 pvm_recognize_specialized_instruction_mull (struct jitter_parameter ** const ps,
5633 bool enable_fast_literals)
5634 __attribute__ ((pure));
5635 inline static enum pvm_specialized_instruction_opcode
5636 pvm_recognize_specialized_instruction_mullu (struct jitter_parameter ** const ps,
5637 bool enable_fast_literals)
5638 __attribute__ ((pure));
5639 inline static enum pvm_specialized_instruction_opcode
5640 pvm_recognize_specialized_instruction_muls (struct jitter_parameter ** const ps,
5641 bool enable_fast_literals)
5642 __attribute__ ((pure));
5643 inline static enum pvm_specialized_instruction_opcode
5644 pvm_recognize_specialized_instruction_negi (struct jitter_parameter ** const ps,
5645 bool enable_fast_literals)
5646 __attribute__ ((pure));
5647 inline static enum pvm_specialized_instruction_opcode
5648 pvm_recognize_specialized_instruction_negiu (struct jitter_parameter ** const ps,
5649 bool enable_fast_literals)
5650 __attribute__ ((pure));
5651 inline static enum pvm_specialized_instruction_opcode
5652 pvm_recognize_specialized_instruction_negl (struct jitter_parameter ** const ps,
5653 bool enable_fast_literals)
5654 __attribute__ ((pure));
5655 inline static enum pvm_specialized_instruction_opcode
5656 pvm_recognize_specialized_instruction_neglu (struct jitter_parameter ** const ps,
5657 bool enable_fast_literals)
5658 __attribute__ ((pure));
5659 inline static enum pvm_specialized_instruction_opcode
5660 pvm_recognize_specialized_instruction_nei (struct jitter_parameter ** const ps,
5661 bool enable_fast_literals)
5662 __attribute__ ((pure));
5663 inline static enum pvm_specialized_instruction_opcode
5664 pvm_recognize_specialized_instruction_neiu (struct jitter_parameter ** const ps,
5665 bool enable_fast_literals)
5666 __attribute__ ((pure));
5667 inline static enum pvm_specialized_instruction_opcode
5668 pvm_recognize_specialized_instruction_nel (struct jitter_parameter ** const ps,
5669 bool enable_fast_literals)
5670 __attribute__ ((pure));
5671 inline static enum pvm_specialized_instruction_opcode
5672 pvm_recognize_specialized_instruction_nelu (struct jitter_parameter ** const ps,
5673 bool enable_fast_literals)
5674 __attribute__ ((pure));
5675 inline static enum pvm_specialized_instruction_opcode
5676 pvm_recognize_specialized_instruction_nes (struct jitter_parameter ** const ps,
5677 bool enable_fast_literals)
5678 __attribute__ ((pure));
5679 inline static enum pvm_specialized_instruction_opcode
5680 pvm_recognize_specialized_instruction_nip (struct jitter_parameter ** const ps,
5681 bool enable_fast_literals)
5682 __attribute__ ((pure));
5683 inline static enum pvm_specialized_instruction_opcode
5684 pvm_recognize_specialized_instruction_nip2 (struct jitter_parameter ** const ps,
5685 bool enable_fast_literals)
5686 __attribute__ ((pure));
5687 inline static enum pvm_specialized_instruction_opcode
5688 pvm_recognize_specialized_instruction_nip3 (struct jitter_parameter ** const ps,
5689 bool enable_fast_literals)
5690 __attribute__ ((pure));
5691 inline static enum pvm_specialized_instruction_opcode
5692 pvm_recognize_specialized_instruction_nn (struct jitter_parameter ** const ps,
5693 bool enable_fast_literals)
5694 __attribute__ ((pure));
5695 inline static enum pvm_specialized_instruction_opcode
5696 pvm_recognize_specialized_instruction_nnn (struct jitter_parameter ** const ps,
5697 bool enable_fast_literals)
5698 __attribute__ ((pure));
5699 inline static enum pvm_specialized_instruction_opcode
5700 pvm_recognize_specialized_instruction_nop (struct jitter_parameter ** const ps,
5701 bool enable_fast_literals)
5702 __attribute__ ((pure));
5703 inline static enum pvm_specialized_instruction_opcode
5704 pvm_recognize_specialized_instruction_not (struct jitter_parameter ** const ps,
5705 bool enable_fast_literals)
5706 __attribute__ ((pure));
5707 inline static enum pvm_specialized_instruction_opcode
5708 pvm_recognize_specialized_instruction_note (struct jitter_parameter ** const ps,
5709 bool enable_fast_literals)
5710 __attribute__ ((pure));
5711 inline static enum pvm_specialized_instruction_opcode
5712 pvm_recognize_specialized_instruction_note__nR (struct jitter_parameter ** const ps,
5713 bool enable_fast_literals)
5714 __attribute__ ((pure));
5715 inline static enum pvm_specialized_instruction_opcode
5716 pvm_recognize_specialized_instruction_nrot (struct jitter_parameter ** const ps,
5717 bool enable_fast_literals)
5718 __attribute__ ((pure));
5719 inline static enum pvm_specialized_instruction_opcode
5720 pvm_recognize_specialized_instruction_ogetbt (struct jitter_parameter ** const ps,
5721 bool enable_fast_literals)
5722 __attribute__ ((pure));
5723 inline static enum pvm_specialized_instruction_opcode
5724 pvm_recognize_specialized_instruction_ogetm (struct jitter_parameter ** const ps,
5725 bool enable_fast_literals)
5726 __attribute__ ((pure));
5727 inline static enum pvm_specialized_instruction_opcode
5728 pvm_recognize_specialized_instruction_ogetu (struct jitter_parameter ** const ps,
5729 bool enable_fast_literals)
5730 __attribute__ ((pure));
5731 inline static enum pvm_specialized_instruction_opcode
5732 pvm_recognize_specialized_instruction_open (struct jitter_parameter ** const ps,
5733 bool enable_fast_literals)
5734 __attribute__ ((pure));
5735 inline static enum pvm_specialized_instruction_opcode
5736 pvm_recognize_specialized_instruction_or (struct jitter_parameter ** const ps,
5737 bool enable_fast_literals)
5738 __attribute__ ((pure));
5739 inline static enum pvm_specialized_instruction_opcode
5740 pvm_recognize_specialized_instruction_osetm (struct jitter_parameter ** const ps,
5741 bool enable_fast_literals)
5742 __attribute__ ((pure));
5743 inline static enum pvm_specialized_instruction_opcode
5744 pvm_recognize_specialized_instruction_over (struct jitter_parameter ** const ps,
5745 bool enable_fast_literals)
5746 __attribute__ ((pure));
5747 inline static enum pvm_specialized_instruction_opcode
5748 pvm_recognize_specialized_instruction_pec (struct jitter_parameter ** const ps,
5749 bool enable_fast_literals)
5750 __attribute__ ((pure));
5751 inline static enum pvm_specialized_instruction_opcode
5752 pvm_recognize_specialized_instruction_peekdi (struct jitter_parameter ** const ps,
5753 bool enable_fast_literals)
5754 __attribute__ ((pure));
5755 inline static enum pvm_specialized_instruction_opcode
5756 pvm_recognize_specialized_instruction_peekdi__nR (struct jitter_parameter ** const ps,
5757 bool enable_fast_literals)
5758 __attribute__ ((pure));
5759 inline static enum pvm_specialized_instruction_opcode
5760 pvm_recognize_specialized_instruction_peekdiu (struct jitter_parameter ** const ps,
5761 bool enable_fast_literals)
5762 __attribute__ ((pure));
5763 inline static enum pvm_specialized_instruction_opcode
5764 pvm_recognize_specialized_instruction_peekdiu__nR (struct jitter_parameter ** const ps,
5765 bool enable_fast_literals)
5766 __attribute__ ((pure));
5767 inline static enum pvm_specialized_instruction_opcode
5768 pvm_recognize_specialized_instruction_peekdl (struct jitter_parameter ** const ps,
5769 bool enable_fast_literals)
5770 __attribute__ ((pure));
5771 inline static enum pvm_specialized_instruction_opcode
5772 pvm_recognize_specialized_instruction_peekdl__nR (struct jitter_parameter ** const ps,
5773 bool enable_fast_literals)
5774 __attribute__ ((pure));
5775 inline static enum pvm_specialized_instruction_opcode
5776 pvm_recognize_specialized_instruction_peekdlu (struct jitter_parameter ** const ps,
5777 bool enable_fast_literals)
5778 __attribute__ ((pure));
5779 inline static enum pvm_specialized_instruction_opcode
5780 pvm_recognize_specialized_instruction_peekdlu__nR (struct jitter_parameter ** const ps,
5781 bool enable_fast_literals)
5782 __attribute__ ((pure));
5783 inline static enum pvm_specialized_instruction_opcode
5784 pvm_recognize_specialized_instruction_peeki (struct jitter_parameter ** const ps,
5785 bool enable_fast_literals)
5786 __attribute__ ((pure));
5787 inline static enum pvm_specialized_instruction_opcode
5788 pvm_recognize_specialized_instruction_peeki__nR (struct jitter_parameter ** const ps,
5789 bool enable_fast_literals)
5790 __attribute__ ((pure));
5791 inline static enum pvm_specialized_instruction_opcode
5792 pvm_recognize_specialized_instruction_peeki__nR__nR (struct jitter_parameter ** const ps,
5793 bool enable_fast_literals)
5794 __attribute__ ((pure));
5795 inline static enum pvm_specialized_instruction_opcode
5796 pvm_recognize_specialized_instruction_peeki__nR__nR__nR (struct jitter_parameter ** const ps,
5797 bool enable_fast_literals)
5798 __attribute__ ((pure));
5799 inline static enum pvm_specialized_instruction_opcode
5800 pvm_recognize_specialized_instruction_peekiu (struct jitter_parameter ** const ps,
5801 bool enable_fast_literals)
5802 __attribute__ ((pure));
5803 inline static enum pvm_specialized_instruction_opcode
5804 pvm_recognize_specialized_instruction_peekiu__nR (struct jitter_parameter ** const ps,
5805 bool enable_fast_literals)
5806 __attribute__ ((pure));
5807 inline static enum pvm_specialized_instruction_opcode
5808 pvm_recognize_specialized_instruction_peekiu__nR__nR (struct jitter_parameter ** const ps,
5809 bool enable_fast_literals)
5810 __attribute__ ((pure));
5811 inline static enum pvm_specialized_instruction_opcode
5812 pvm_recognize_specialized_instruction_peekl (struct jitter_parameter ** const ps,
5813 bool enable_fast_literals)
5814 __attribute__ ((pure));
5815 inline static enum pvm_specialized_instruction_opcode
5816 pvm_recognize_specialized_instruction_peekl__nR (struct jitter_parameter ** const ps,
5817 bool enable_fast_literals)
5818 __attribute__ ((pure));
5819 inline static enum pvm_specialized_instruction_opcode
5820 pvm_recognize_specialized_instruction_peekl__nR__nR (struct jitter_parameter ** const ps,
5821 bool enable_fast_literals)
5822 __attribute__ ((pure));
5823 inline static enum pvm_specialized_instruction_opcode
5824 pvm_recognize_specialized_instruction_peekl__nR__nR__nR (struct jitter_parameter ** const ps,
5825 bool enable_fast_literals)
5826 __attribute__ ((pure));
5827 inline static enum pvm_specialized_instruction_opcode
5828 pvm_recognize_specialized_instruction_peeklu (struct jitter_parameter ** const ps,
5829 bool enable_fast_literals)
5830 __attribute__ ((pure));
5831 inline static enum pvm_specialized_instruction_opcode
5832 pvm_recognize_specialized_instruction_peeklu__nR (struct jitter_parameter ** const ps,
5833 bool enable_fast_literals)
5834 __attribute__ ((pure));
5835 inline static enum pvm_specialized_instruction_opcode
5836 pvm_recognize_specialized_instruction_peeklu__nR__nR (struct jitter_parameter ** const ps,
5837 bool enable_fast_literals)
5838 __attribute__ ((pure));
5839 inline static enum pvm_specialized_instruction_opcode
5840 pvm_recognize_specialized_instruction_peeks (struct jitter_parameter ** const ps,
5841 bool enable_fast_literals)
5842 __attribute__ ((pure));
5843 inline static enum pvm_specialized_instruction_opcode
5844 pvm_recognize_specialized_instruction_pokedi (struct jitter_parameter ** const ps,
5845 bool enable_fast_literals)
5846 __attribute__ ((pure));
5847 inline static enum pvm_specialized_instruction_opcode
5848 pvm_recognize_specialized_instruction_pokedi__nR (struct jitter_parameter ** const ps,
5849 bool enable_fast_literals)
5850 __attribute__ ((pure));
5851 inline static enum pvm_specialized_instruction_opcode
5852 pvm_recognize_specialized_instruction_pokediu (struct jitter_parameter ** const ps,
5853 bool enable_fast_literals)
5854 __attribute__ ((pure));
5855 inline static enum pvm_specialized_instruction_opcode
5856 pvm_recognize_specialized_instruction_pokediu__nR (struct jitter_parameter ** const ps,
5857 bool enable_fast_literals)
5858 __attribute__ ((pure));
5859 inline static enum pvm_specialized_instruction_opcode
5860 pvm_recognize_specialized_instruction_pokedl (struct jitter_parameter ** const ps,
5861 bool enable_fast_literals)
5862 __attribute__ ((pure));
5863 inline static enum pvm_specialized_instruction_opcode
5864 pvm_recognize_specialized_instruction_pokedl__nR (struct jitter_parameter ** const ps,
5865 bool enable_fast_literals)
5866 __attribute__ ((pure));
5867 inline static enum pvm_specialized_instruction_opcode
5868 pvm_recognize_specialized_instruction_pokedlu (struct jitter_parameter ** const ps,
5869 bool enable_fast_literals)
5870 __attribute__ ((pure));
5871 inline static enum pvm_specialized_instruction_opcode
5872 pvm_recognize_specialized_instruction_pokedlu__nR (struct jitter_parameter ** const ps,
5873 bool enable_fast_literals)
5874 __attribute__ ((pure));
5875 inline static enum pvm_specialized_instruction_opcode
5876 pvm_recognize_specialized_instruction_pokei (struct jitter_parameter ** const ps,
5877 bool enable_fast_literals)
5878 __attribute__ ((pure));
5879 inline static enum pvm_specialized_instruction_opcode
5880 pvm_recognize_specialized_instruction_pokei__nR (struct jitter_parameter ** const ps,
5881 bool enable_fast_literals)
5882 __attribute__ ((pure));
5883 inline static enum pvm_specialized_instruction_opcode
5884 pvm_recognize_specialized_instruction_pokei__nR__nR (struct jitter_parameter ** const ps,
5885 bool enable_fast_literals)
5886 __attribute__ ((pure));
5887 inline static enum pvm_specialized_instruction_opcode
5888 pvm_recognize_specialized_instruction_pokei__nR__nR__nR (struct jitter_parameter ** const ps,
5889 bool enable_fast_literals)
5890 __attribute__ ((pure));
5891 inline static enum pvm_specialized_instruction_opcode
5892 pvm_recognize_specialized_instruction_pokeiu (struct jitter_parameter ** const ps,
5893 bool enable_fast_literals)
5894 __attribute__ ((pure));
5895 inline static enum pvm_specialized_instruction_opcode
5896 pvm_recognize_specialized_instruction_pokeiu__nR (struct jitter_parameter ** const ps,
5897 bool enable_fast_literals)
5898 __attribute__ ((pure));
5899 inline static enum pvm_specialized_instruction_opcode
5900 pvm_recognize_specialized_instruction_pokeiu__nR__nR (struct jitter_parameter ** const ps,
5901 bool enable_fast_literals)
5902 __attribute__ ((pure));
5903 inline static enum pvm_specialized_instruction_opcode
5904 pvm_recognize_specialized_instruction_pokel (struct jitter_parameter ** const ps,
5905 bool enable_fast_literals)
5906 __attribute__ ((pure));
5907 inline static enum pvm_specialized_instruction_opcode
5908 pvm_recognize_specialized_instruction_pokel__nR (struct jitter_parameter ** const ps,
5909 bool enable_fast_literals)
5910 __attribute__ ((pure));
5911 inline static enum pvm_specialized_instruction_opcode
5912 pvm_recognize_specialized_instruction_pokel__nR__nR (struct jitter_parameter ** const ps,
5913 bool enable_fast_literals)
5914 __attribute__ ((pure));
5915 inline static enum pvm_specialized_instruction_opcode
5916 pvm_recognize_specialized_instruction_pokel__nR__nR__nR (struct jitter_parameter ** const ps,
5917 bool enable_fast_literals)
5918 __attribute__ ((pure));
5919 inline static enum pvm_specialized_instruction_opcode
5920 pvm_recognize_specialized_instruction_pokelu (struct jitter_parameter ** const ps,
5921 bool enable_fast_literals)
5922 __attribute__ ((pure));
5923 inline static enum pvm_specialized_instruction_opcode
5924 pvm_recognize_specialized_instruction_pokelu__nR (struct jitter_parameter ** const ps,
5925 bool enable_fast_literals)
5926 __attribute__ ((pure));
5927 inline static enum pvm_specialized_instruction_opcode
5928 pvm_recognize_specialized_instruction_pokelu__nR__nR (struct jitter_parameter ** const ps,
5929 bool enable_fast_literals)
5930 __attribute__ ((pure));
5931 inline static enum pvm_specialized_instruction_opcode
5932 pvm_recognize_specialized_instruction_pokes (struct jitter_parameter ** const ps,
5933 bool enable_fast_literals)
5934 __attribute__ ((pure));
5935 inline static enum pvm_specialized_instruction_opcode
5936 pvm_recognize_specialized_instruction_pope (struct jitter_parameter ** const ps,
5937 bool enable_fast_literals)
5938 __attribute__ ((pure));
5939 inline static enum pvm_specialized_instruction_opcode
5940 pvm_recognize_specialized_instruction_popend (struct jitter_parameter ** const ps,
5941 bool enable_fast_literals)
5942 __attribute__ ((pure));
5943 inline static enum pvm_specialized_instruction_opcode
5944 pvm_recognize_specialized_instruction_popf (struct jitter_parameter ** const ps,
5945 bool enable_fast_literals)
5946 __attribute__ ((pure));
5947 inline static enum pvm_specialized_instruction_opcode
5948 pvm_recognize_specialized_instruction_popf__nR (struct jitter_parameter ** const ps,
5949 bool enable_fast_literals)
5950 __attribute__ ((pure));
5951 inline static enum pvm_specialized_instruction_opcode
5952 pvm_recognize_specialized_instruction_popios (struct jitter_parameter ** const ps,
5953 bool enable_fast_literals)
5954 __attribute__ ((pure));
5955 inline static enum pvm_specialized_instruction_opcode
5956 pvm_recognize_specialized_instruction_popoac (struct jitter_parameter ** const ps,
5957 bool enable_fast_literals)
5958 __attribute__ ((pure));
5959 inline static enum pvm_specialized_instruction_opcode
5960 pvm_recognize_specialized_instruction_popob (struct jitter_parameter ** const ps,
5961 bool enable_fast_literals)
5962 __attribute__ ((pure));
5963 inline static enum pvm_specialized_instruction_opcode
5964 pvm_recognize_specialized_instruction_popobc (struct jitter_parameter ** const ps,
5965 bool enable_fast_literals)
5966 __attribute__ ((pure));
5967 inline static enum pvm_specialized_instruction_opcode
5968 pvm_recognize_specialized_instruction_popoc (struct jitter_parameter ** const ps,
5969 bool enable_fast_literals)
5970 __attribute__ ((pure));
5971 inline static enum pvm_specialized_instruction_opcode
5972 pvm_recognize_specialized_instruction_popod (struct jitter_parameter ** const ps,
5973 bool enable_fast_literals)
5974 __attribute__ ((pure));
5975 inline static enum pvm_specialized_instruction_opcode
5976 pvm_recognize_specialized_instruction_popoi (struct jitter_parameter ** const ps,
5977 bool enable_fast_literals)
5978 __attribute__ ((pure));
5979 inline static enum pvm_specialized_instruction_opcode
5980 pvm_recognize_specialized_instruction_popom (struct jitter_parameter ** const ps,
5981 bool enable_fast_literals)
5982 __attribute__ ((pure));
5983 inline static enum pvm_specialized_instruction_opcode
5984 pvm_recognize_specialized_instruction_popoo (struct jitter_parameter ** const ps,
5985 bool enable_fast_literals)
5986 __attribute__ ((pure));
5987 inline static enum pvm_specialized_instruction_opcode
5988 pvm_recognize_specialized_instruction_popopp (struct jitter_parameter ** const ps,
5989 bool enable_fast_literals)
5990 __attribute__ ((pure));
5991 inline static enum pvm_specialized_instruction_opcode
5992 pvm_recognize_specialized_instruction_popr (struct jitter_parameter ** const ps,
5993 bool enable_fast_literals)
5994 __attribute__ ((pure));
5995 inline static enum pvm_specialized_instruction_opcode
5996 pvm_recognize_specialized_instruction_popr___rrR (struct jitter_parameter ** const ps,
5997 bool enable_fast_literals)
5998 __attribute__ ((pure));
5999 inline static enum pvm_specialized_instruction_opcode
6000 pvm_recognize_specialized_instruction_popvar (struct jitter_parameter ** const ps,
6001 bool enable_fast_literals)
6002 __attribute__ ((pure));
6003 inline static enum pvm_specialized_instruction_opcode
6004 pvm_recognize_specialized_instruction_popvar__nR (struct jitter_parameter ** const ps,
6005 bool enable_fast_literals)
6006 __attribute__ ((pure));
6007 inline static enum pvm_specialized_instruction_opcode
6008 pvm_recognize_specialized_instruction_popvar__nR__nR (struct jitter_parameter ** const ps,
6009 bool enable_fast_literals)
6010 __attribute__ ((pure));
6011 inline static enum pvm_specialized_instruction_opcode
6012 pvm_recognize_specialized_instruction_powi (struct jitter_parameter ** const ps,
6013 bool enable_fast_literals)
6014 __attribute__ ((pure));
6015 inline static enum pvm_specialized_instruction_opcode
6016 pvm_recognize_specialized_instruction_powiu (struct jitter_parameter ** const ps,
6017 bool enable_fast_literals)
6018 __attribute__ ((pure));
6019 inline static enum pvm_specialized_instruction_opcode
6020 pvm_recognize_specialized_instruction_powl (struct jitter_parameter ** const ps,
6021 bool enable_fast_literals)
6022 __attribute__ ((pure));
6023 inline static enum pvm_specialized_instruction_opcode
6024 pvm_recognize_specialized_instruction_powlu (struct jitter_parameter ** const ps,
6025 bool enable_fast_literals)
6026 __attribute__ ((pure));
6027 inline static enum pvm_specialized_instruction_opcode
6028 pvm_recognize_specialized_instruction_printi (struct jitter_parameter ** const ps,
6029 bool enable_fast_literals)
6030 __attribute__ ((pure));
6031 inline static enum pvm_specialized_instruction_opcode
6032 pvm_recognize_specialized_instruction_printi__nR (struct jitter_parameter ** const ps,
6033 bool enable_fast_literals)
6034 __attribute__ ((pure));
6035 inline static enum pvm_specialized_instruction_opcode
6036 pvm_recognize_specialized_instruction_printiu (struct jitter_parameter ** const ps,
6037 bool enable_fast_literals)
6038 __attribute__ ((pure));
6039 inline static enum pvm_specialized_instruction_opcode
6040 pvm_recognize_specialized_instruction_printiu__nR (struct jitter_parameter ** const ps,
6041 bool enable_fast_literals)
6042 __attribute__ ((pure));
6043 inline static enum pvm_specialized_instruction_opcode
6044 pvm_recognize_specialized_instruction_printl (struct jitter_parameter ** const ps,
6045 bool enable_fast_literals)
6046 __attribute__ ((pure));
6047 inline static enum pvm_specialized_instruction_opcode
6048 pvm_recognize_specialized_instruction_printl__nR (struct jitter_parameter ** const ps,
6049 bool enable_fast_literals)
6050 __attribute__ ((pure));
6051 inline static enum pvm_specialized_instruction_opcode
6052 pvm_recognize_specialized_instruction_printlu (struct jitter_parameter ** const ps,
6053 bool enable_fast_literals)
6054 __attribute__ ((pure));
6055 inline static enum pvm_specialized_instruction_opcode
6056 pvm_recognize_specialized_instruction_printlu__nR (struct jitter_parameter ** const ps,
6057 bool enable_fast_literals)
6058 __attribute__ ((pure));
6059 inline static enum pvm_specialized_instruction_opcode
6060 pvm_recognize_specialized_instruction_prints (struct jitter_parameter ** const ps,
6061 bool enable_fast_literals)
6062 __attribute__ ((pure));
6063 inline static enum pvm_specialized_instruction_opcode
6064 pvm_recognize_specialized_instruction_prolog (struct jitter_parameter ** const ps,
6065 bool enable_fast_literals)
6066 __attribute__ ((pure));
6067 inline static enum pvm_specialized_instruction_opcode
6068 pvm_recognize_specialized_instruction_push (struct jitter_parameter ** const ps,
6069 bool enable_fast_literals)
6070 __attribute__ ((pure));
6071 inline static enum pvm_specialized_instruction_opcode
6072 pvm_recognize_specialized_instruction_push__nR (struct jitter_parameter ** const ps,
6073 bool enable_fast_literals)
6074 __attribute__ ((pure));
6075 inline static enum pvm_specialized_instruction_opcode
6076 pvm_recognize_specialized_instruction_push__lR (struct jitter_parameter ** const ps,
6077 bool enable_fast_literals)
6078 __attribute__ ((pure));
6079 inline static enum pvm_specialized_instruction_opcode
6080 pvm_recognize_specialized_instruction_push32 (struct jitter_parameter ** const ps,
6081 bool enable_fast_literals)
6082 __attribute__ ((pure));
6083 inline static enum pvm_specialized_instruction_opcode
6084 pvm_recognize_specialized_instruction_push32__nR (struct jitter_parameter ** const ps,
6085 bool enable_fast_literals)
6086 __attribute__ ((pure));
6087 inline static enum pvm_specialized_instruction_opcode
6088 pvm_recognize_specialized_instruction_push32__lR (struct jitter_parameter ** const ps,
6089 bool enable_fast_literals)
6090 __attribute__ ((pure));
6091 inline static enum pvm_specialized_instruction_opcode
6092 pvm_recognize_specialized_instruction_pushe (struct jitter_parameter ** const ps,
6093 bool enable_fast_literals)
6094 __attribute__ ((pure));
6095 inline static enum pvm_specialized_instruction_opcode
6096 pvm_recognize_specialized_instruction_pushe__lR (struct jitter_parameter ** const ps,
6097 bool enable_fast_literals)
6098 __attribute__ ((pure));
6099 inline static enum pvm_specialized_instruction_opcode
6100 pvm_recognize_specialized_instruction_pushend (struct jitter_parameter ** const ps,
6101 bool enable_fast_literals)
6102 __attribute__ ((pure));
6103 inline static enum pvm_specialized_instruction_opcode
6104 pvm_recognize_specialized_instruction_pushf (struct jitter_parameter ** const ps,
6105 bool enable_fast_literals)
6106 __attribute__ ((pure));
6107 inline static enum pvm_specialized_instruction_opcode
6108 pvm_recognize_specialized_instruction_pushf__nR (struct jitter_parameter ** const ps,
6109 bool enable_fast_literals)
6110 __attribute__ ((pure));
6111 inline static enum pvm_specialized_instruction_opcode
6112 pvm_recognize_specialized_instruction_pushhi (struct jitter_parameter ** const ps,
6113 bool enable_fast_literals)
6114 __attribute__ ((pure));
6115 inline static enum pvm_specialized_instruction_opcode
6116 pvm_recognize_specialized_instruction_pushhi__nR (struct jitter_parameter ** const ps,
6117 bool enable_fast_literals)
6118 __attribute__ ((pure));
6119 inline static enum pvm_specialized_instruction_opcode
6120 pvm_recognize_specialized_instruction_pushhi__lR (struct jitter_parameter ** const ps,
6121 bool enable_fast_literals)
6122 __attribute__ ((pure));
6123 inline static enum pvm_specialized_instruction_opcode
6124 pvm_recognize_specialized_instruction_pushios (struct jitter_parameter ** const ps,
6125 bool enable_fast_literals)
6126 __attribute__ ((pure));
6127 inline static enum pvm_specialized_instruction_opcode
6128 pvm_recognize_specialized_instruction_pushlo (struct jitter_parameter ** const ps,
6129 bool enable_fast_literals)
6130 __attribute__ ((pure));
6131 inline static enum pvm_specialized_instruction_opcode
6132 pvm_recognize_specialized_instruction_pushlo__nR (struct jitter_parameter ** const ps,
6133 bool enable_fast_literals)
6134 __attribute__ ((pure));
6135 inline static enum pvm_specialized_instruction_opcode
6136 pvm_recognize_specialized_instruction_pushlo__lR (struct jitter_parameter ** const ps,
6137 bool enable_fast_literals)
6138 __attribute__ ((pure));
6139 inline static enum pvm_specialized_instruction_opcode
6140 pvm_recognize_specialized_instruction_pushoac (struct jitter_parameter ** const ps,
6141 bool enable_fast_literals)
6142 __attribute__ ((pure));
6143 inline static enum pvm_specialized_instruction_opcode
6144 pvm_recognize_specialized_instruction_pushob (struct jitter_parameter ** const ps,
6145 bool enable_fast_literals)
6146 __attribute__ ((pure));
6147 inline static enum pvm_specialized_instruction_opcode
6148 pvm_recognize_specialized_instruction_pushobc (struct jitter_parameter ** const ps,
6149 bool enable_fast_literals)
6150 __attribute__ ((pure));
6151 inline static enum pvm_specialized_instruction_opcode
6152 pvm_recognize_specialized_instruction_pushoc (struct jitter_parameter ** const ps,
6153 bool enable_fast_literals)
6154 __attribute__ ((pure));
6155 inline static enum pvm_specialized_instruction_opcode
6156 pvm_recognize_specialized_instruction_pushod (struct jitter_parameter ** const ps,
6157 bool enable_fast_literals)
6158 __attribute__ ((pure));
6159 inline static enum pvm_specialized_instruction_opcode
6160 pvm_recognize_specialized_instruction_pushoi (struct jitter_parameter ** const ps,
6161 bool enable_fast_literals)
6162 __attribute__ ((pure));
6163 inline static enum pvm_specialized_instruction_opcode
6164 pvm_recognize_specialized_instruction_pushom (struct jitter_parameter ** const ps,
6165 bool enable_fast_literals)
6166 __attribute__ ((pure));
6167 inline static enum pvm_specialized_instruction_opcode
6168 pvm_recognize_specialized_instruction_pushoo (struct jitter_parameter ** const ps,
6169 bool enable_fast_literals)
6170 __attribute__ ((pure));
6171 inline static enum pvm_specialized_instruction_opcode
6172 pvm_recognize_specialized_instruction_pushopp (struct jitter_parameter ** const ps,
6173 bool enable_fast_literals)
6174 __attribute__ ((pure));
6175 inline static enum pvm_specialized_instruction_opcode
6176 pvm_recognize_specialized_instruction_pushr (struct jitter_parameter ** const ps,
6177 bool enable_fast_literals)
6178 __attribute__ ((pure));
6179 inline static enum pvm_specialized_instruction_opcode
6180 pvm_recognize_specialized_instruction_pushr___rrR (struct jitter_parameter ** const ps,
6181 bool enable_fast_literals)
6182 __attribute__ ((pure));
6183 inline static enum pvm_specialized_instruction_opcode
6184 pvm_recognize_specialized_instruction_pushtopvar (struct jitter_parameter ** const ps,
6185 bool enable_fast_literals)
6186 __attribute__ ((pure));
6187 inline static enum pvm_specialized_instruction_opcode
6188 pvm_recognize_specialized_instruction_pushtopvar__nR (struct jitter_parameter ** const ps,
6189 bool enable_fast_literals)
6190 __attribute__ ((pure));
6191 inline static enum pvm_specialized_instruction_opcode
6192 pvm_recognize_specialized_instruction_pushvar (struct jitter_parameter ** const ps,
6193 bool enable_fast_literals)
6194 __attribute__ ((pure));
6195 inline static enum pvm_specialized_instruction_opcode
6196 pvm_recognize_specialized_instruction_pushvar__n0 (struct jitter_parameter ** const ps,
6197 bool enable_fast_literals)
6198 __attribute__ ((pure));
6199 inline static enum pvm_specialized_instruction_opcode
6200 pvm_recognize_specialized_instruction_pushvar__n0__n0 (struct jitter_parameter ** const ps,
6201 bool enable_fast_literals)
6202 __attribute__ ((pure));
6203 inline static enum pvm_specialized_instruction_opcode
6204 pvm_recognize_specialized_instruction_pushvar__n0__n1 (struct jitter_parameter ** const ps,
6205 bool enable_fast_literals)
6206 __attribute__ ((pure));
6207 inline static enum pvm_specialized_instruction_opcode
6208 pvm_recognize_specialized_instruction_pushvar__n0__n2 (struct jitter_parameter ** const ps,
6209 bool enable_fast_literals)
6210 __attribute__ ((pure));
6211 inline static enum pvm_specialized_instruction_opcode
6212 pvm_recognize_specialized_instruction_pushvar__n0__n3 (struct jitter_parameter ** const ps,
6213 bool enable_fast_literals)
6214 __attribute__ ((pure));
6215 inline static enum pvm_specialized_instruction_opcode
6216 pvm_recognize_specialized_instruction_pushvar__n0__n4 (struct jitter_parameter ** const ps,
6217 bool enable_fast_literals)
6218 __attribute__ ((pure));
6219 inline static enum pvm_specialized_instruction_opcode
6220 pvm_recognize_specialized_instruction_pushvar__n0__n5 (struct jitter_parameter ** const ps,
6221 bool enable_fast_literals)
6222 __attribute__ ((pure));
6223 inline static enum pvm_specialized_instruction_opcode
6224 pvm_recognize_specialized_instruction_pushvar__n0__nR (struct jitter_parameter ** const ps,
6225 bool enable_fast_literals)
6226 __attribute__ ((pure));
6227 inline static enum pvm_specialized_instruction_opcode
6228 pvm_recognize_specialized_instruction_pushvar__nR (struct jitter_parameter ** const ps,
6229 bool enable_fast_literals)
6230 __attribute__ ((pure));
6231 inline static enum pvm_specialized_instruction_opcode
6232 pvm_recognize_specialized_instruction_pushvar__nR__n0 (struct jitter_parameter ** const ps,
6233 bool enable_fast_literals)
6234 __attribute__ ((pure));
6235 inline static enum pvm_specialized_instruction_opcode
6236 pvm_recognize_specialized_instruction_pushvar__nR__n1 (struct jitter_parameter ** const ps,
6237 bool enable_fast_literals)
6238 __attribute__ ((pure));
6239 inline static enum pvm_specialized_instruction_opcode
6240 pvm_recognize_specialized_instruction_pushvar__nR__n2 (struct jitter_parameter ** const ps,
6241 bool enable_fast_literals)
6242 __attribute__ ((pure));
6243 inline static enum pvm_specialized_instruction_opcode
6244 pvm_recognize_specialized_instruction_pushvar__nR__n3 (struct jitter_parameter ** const ps,
6245 bool enable_fast_literals)
6246 __attribute__ ((pure));
6247 inline static enum pvm_specialized_instruction_opcode
6248 pvm_recognize_specialized_instruction_pushvar__nR__n4 (struct jitter_parameter ** const ps,
6249 bool enable_fast_literals)
6250 __attribute__ ((pure));
6251 inline static enum pvm_specialized_instruction_opcode
6252 pvm_recognize_specialized_instruction_pushvar__nR__n5 (struct jitter_parameter ** const ps,
6253 bool enable_fast_literals)
6254 __attribute__ ((pure));
6255 inline static enum pvm_specialized_instruction_opcode
6256 pvm_recognize_specialized_instruction_pushvar__nR__nR (struct jitter_parameter ** const ps,
6257 bool enable_fast_literals)
6258 __attribute__ ((pure));
6259 inline static enum pvm_specialized_instruction_opcode
6260 pvm_recognize_specialized_instruction_quake (struct jitter_parameter ** const ps,
6261 bool enable_fast_literals)
6262 __attribute__ ((pure));
6263 inline static enum pvm_specialized_instruction_opcode
6264 pvm_recognize_specialized_instruction_raise (struct jitter_parameter ** const ps,
6265 bool enable_fast_literals)
6266 __attribute__ ((pure));
6267 inline static enum pvm_specialized_instruction_opcode
6268 pvm_recognize_specialized_instruction_rand (struct jitter_parameter ** const ps,
6269 bool enable_fast_literals)
6270 __attribute__ ((pure));
6271 inline static enum pvm_specialized_instruction_opcode
6272 pvm_recognize_specialized_instruction_regvar (struct jitter_parameter ** const ps,
6273 bool enable_fast_literals)
6274 __attribute__ ((pure));
6275 inline static enum pvm_specialized_instruction_opcode
6276 pvm_recognize_specialized_instruction_reloc (struct jitter_parameter ** const ps,
6277 bool enable_fast_literals)
6278 __attribute__ ((pure));
6279 inline static enum pvm_specialized_instruction_opcode
6280 pvm_recognize_specialized_instruction_restorer (struct jitter_parameter ** const ps,
6281 bool enable_fast_literals)
6282 __attribute__ ((pure));
6283 inline static enum pvm_specialized_instruction_opcode
6284 pvm_recognize_specialized_instruction_restorer___rrR (struct jitter_parameter ** const ps,
6285 bool enable_fast_literals)
6286 __attribute__ ((pure));
6287 inline static enum pvm_specialized_instruction_opcode
6288 pvm_recognize_specialized_instruction_return (struct jitter_parameter ** const ps,
6289 bool enable_fast_literals)
6290 __attribute__ ((pure));
6291 inline static enum pvm_specialized_instruction_opcode
6292 pvm_recognize_specialized_instruction_revn (struct jitter_parameter ** const ps,
6293 bool enable_fast_literals)
6294 __attribute__ ((pure));
6295 inline static enum pvm_specialized_instruction_opcode
6296 pvm_recognize_specialized_instruction_revn__n3 (struct jitter_parameter ** const ps,
6297 bool enable_fast_literals)
6298 __attribute__ ((pure));
6299 inline static enum pvm_specialized_instruction_opcode
6300 pvm_recognize_specialized_instruction_revn__n4 (struct jitter_parameter ** const ps,
6301 bool enable_fast_literals)
6302 __attribute__ ((pure));
6303 inline static enum pvm_specialized_instruction_opcode
6304 pvm_recognize_specialized_instruction_revn__nR (struct jitter_parameter ** const ps,
6305 bool enable_fast_literals)
6306 __attribute__ ((pure));
6307 inline static enum pvm_specialized_instruction_opcode
6308 pvm_recognize_specialized_instruction_rot (struct jitter_parameter ** const ps,
6309 bool enable_fast_literals)
6310 __attribute__ ((pure));
6311 inline static enum pvm_specialized_instruction_opcode
6312 pvm_recognize_specialized_instruction_saver (struct jitter_parameter ** const ps,
6313 bool enable_fast_literals)
6314 __attribute__ ((pure));
6315 inline static enum pvm_specialized_instruction_opcode
6316 pvm_recognize_specialized_instruction_saver___rrR (struct jitter_parameter ** const ps,
6317 bool enable_fast_literals)
6318 __attribute__ ((pure));
6319 inline static enum pvm_specialized_instruction_opcode
6320 pvm_recognize_specialized_instruction_sconc (struct jitter_parameter ** const ps,
6321 bool enable_fast_literals)
6322 __attribute__ ((pure));
6323 inline static enum pvm_specialized_instruction_opcode
6324 pvm_recognize_specialized_instruction_sel (struct jitter_parameter ** const ps,
6325 bool enable_fast_literals)
6326 __attribute__ ((pure));
6327 inline static enum pvm_specialized_instruction_opcode
6328 pvm_recognize_specialized_instruction_setr (struct jitter_parameter ** const ps,
6329 bool enable_fast_literals)
6330 __attribute__ ((pure));
6331 inline static enum pvm_specialized_instruction_opcode
6332 pvm_recognize_specialized_instruction_setr___rrR (struct jitter_parameter ** const ps,
6333 bool enable_fast_literals)
6334 __attribute__ ((pure));
6335 inline static enum pvm_specialized_instruction_opcode
6336 pvm_recognize_specialized_instruction_siz (struct jitter_parameter ** const ps,
6337 bool enable_fast_literals)
6338 __attribute__ ((pure));
6339 inline static enum pvm_specialized_instruction_opcode
6340 pvm_recognize_specialized_instruction_smodi (struct jitter_parameter ** const ps,
6341 bool enable_fast_literals)
6342 __attribute__ ((pure));
6343 inline static enum pvm_specialized_instruction_opcode
6344 pvm_recognize_specialized_instruction_sref (struct jitter_parameter ** const ps,
6345 bool enable_fast_literals)
6346 __attribute__ ((pure));
6347 inline static enum pvm_specialized_instruction_opcode
6348 pvm_recognize_specialized_instruction_srefi (struct jitter_parameter ** const ps,
6349 bool enable_fast_literals)
6350 __attribute__ ((pure));
6351 inline static enum pvm_specialized_instruction_opcode
6352 pvm_recognize_specialized_instruction_srefia (struct jitter_parameter ** const ps,
6353 bool enable_fast_literals)
6354 __attribute__ ((pure));
6355 inline static enum pvm_specialized_instruction_opcode
6356 pvm_recognize_specialized_instruction_srefio (struct jitter_parameter ** const ps,
6357 bool enable_fast_literals)
6358 __attribute__ ((pure));
6359 inline static enum pvm_specialized_instruction_opcode
6360 pvm_recognize_specialized_instruction_srefmnt (struct jitter_parameter ** const ps,
6361 bool enable_fast_literals)
6362 __attribute__ ((pure));
6363 inline static enum pvm_specialized_instruction_opcode
6364 pvm_recognize_specialized_instruction_srefnt (struct jitter_parameter ** const ps,
6365 bool enable_fast_literals)
6366 __attribute__ ((pure));
6367 inline static enum pvm_specialized_instruction_opcode
6368 pvm_recognize_specialized_instruction_srefo (struct jitter_parameter ** const ps,
6369 bool enable_fast_literals)
6370 __attribute__ ((pure));
6371 inline static enum pvm_specialized_instruction_opcode
6372 pvm_recognize_specialized_instruction_sset (struct jitter_parameter ** const ps,
6373 bool enable_fast_literals)
6374 __attribute__ ((pure));
6375 inline static enum pvm_specialized_instruction_opcode
6376 pvm_recognize_specialized_instruction_strace (struct jitter_parameter ** const ps,
6377 bool enable_fast_literals)
6378 __attribute__ ((pure));
6379 inline static enum pvm_specialized_instruction_opcode
6380 pvm_recognize_specialized_instruction_strace__nR (struct jitter_parameter ** const ps,
6381 bool enable_fast_literals)
6382 __attribute__ ((pure));
6383 inline static enum pvm_specialized_instruction_opcode
6384 pvm_recognize_specialized_instruction_strref (struct jitter_parameter ** const ps,
6385 bool enable_fast_literals)
6386 __attribute__ ((pure));
6387 inline static enum pvm_specialized_instruction_opcode
6388 pvm_recognize_specialized_instruction_subi (struct jitter_parameter ** const ps,
6389 bool enable_fast_literals)
6390 __attribute__ ((pure));
6391 inline static enum pvm_specialized_instruction_opcode
6392 pvm_recognize_specialized_instruction_subiu (struct jitter_parameter ** const ps,
6393 bool enable_fast_literals)
6394 __attribute__ ((pure));
6395 inline static enum pvm_specialized_instruction_opcode
6396 pvm_recognize_specialized_instruction_subl (struct jitter_parameter ** const ps,
6397 bool enable_fast_literals)
6398 __attribute__ ((pure));
6399 inline static enum pvm_specialized_instruction_opcode
6400 pvm_recognize_specialized_instruction_sublu (struct jitter_parameter ** const ps,
6401 bool enable_fast_literals)
6402 __attribute__ ((pure));
6403 inline static enum pvm_specialized_instruction_opcode
6404 pvm_recognize_specialized_instruction_substr (struct jitter_parameter ** const ps,
6405 bool enable_fast_literals)
6406 __attribute__ ((pure));
6407 inline static enum pvm_specialized_instruction_opcode
6408 pvm_recognize_specialized_instruction_swap (struct jitter_parameter ** const ps,
6409 bool enable_fast_literals)
6410 __attribute__ ((pure));
6411 inline static enum pvm_specialized_instruction_opcode
6412 pvm_recognize_specialized_instruction_swapgti (struct jitter_parameter ** const ps,
6413 bool enable_fast_literals)
6414 __attribute__ ((pure));
6415 inline static enum pvm_specialized_instruction_opcode
6416 pvm_recognize_specialized_instruction_swapgtiu (struct jitter_parameter ** const ps,
6417 bool enable_fast_literals)
6418 __attribute__ ((pure));
6419 inline static enum pvm_specialized_instruction_opcode
6420 pvm_recognize_specialized_instruction_swapgtl (struct jitter_parameter ** const ps,
6421 bool enable_fast_literals)
6422 __attribute__ ((pure));
6423 inline static enum pvm_specialized_instruction_opcode
6424 pvm_recognize_specialized_instruction_swapgtlu (struct jitter_parameter ** const ps,
6425 bool enable_fast_literals)
6426 __attribute__ ((pure));
6427 inline static enum pvm_specialized_instruction_opcode
6428 pvm_recognize_specialized_instruction_sync (struct jitter_parameter ** const ps,
6429 bool enable_fast_literals)
6430 __attribute__ ((pure));
6431 inline static enum pvm_specialized_instruction_opcode
6432 pvm_recognize_specialized_instruction_time (struct jitter_parameter ** const ps,
6433 bool enable_fast_literals)
6434 __attribute__ ((pure));
6435 inline static enum pvm_specialized_instruction_opcode
6436 pvm_recognize_specialized_instruction_tor (struct jitter_parameter ** const ps,
6437 bool enable_fast_literals)
6438 __attribute__ ((pure));
6439 inline static enum pvm_specialized_instruction_opcode
6440 pvm_recognize_specialized_instruction_tuck (struct jitter_parameter ** const ps,
6441 bool enable_fast_literals)
6442 __attribute__ ((pure));
6443 inline static enum pvm_specialized_instruction_opcode
6444 pvm_recognize_specialized_instruction_tyagetb (struct jitter_parameter ** const ps,
6445 bool enable_fast_literals)
6446 __attribute__ ((pure));
6447 inline static enum pvm_specialized_instruction_opcode
6448 pvm_recognize_specialized_instruction_tyagett (struct jitter_parameter ** const ps,
6449 bool enable_fast_literals)
6450 __attribute__ ((pure));
6451 inline static enum pvm_specialized_instruction_opcode
6452 pvm_recognize_specialized_instruction_tyisc (struct jitter_parameter ** const ps,
6453 bool enable_fast_literals)
6454 __attribute__ ((pure));
6455 inline static enum pvm_specialized_instruction_opcode
6456 pvm_recognize_specialized_instruction_tyissct (struct jitter_parameter ** const ps,
6457 bool enable_fast_literals)
6458 __attribute__ ((pure));
6459 inline static enum pvm_specialized_instruction_opcode
6460 pvm_recognize_specialized_instruction_typof (struct jitter_parameter ** const ps,
6461 bool enable_fast_literals)
6462 __attribute__ ((pure));
6463 inline static enum pvm_specialized_instruction_opcode
6464 pvm_recognize_specialized_instruction_tysctn (struct jitter_parameter ** const ps,
6465 bool enable_fast_literals)
6466 __attribute__ ((pure));
6467 inline static enum pvm_specialized_instruction_opcode
6468 pvm_recognize_specialized_instruction_unmap (struct jitter_parameter ** const ps,
6469 bool enable_fast_literals)
6470 __attribute__ ((pure));
6471 inline static enum pvm_specialized_instruction_opcode
6472 pvm_recognize_specialized_instruction_unreachable (struct jitter_parameter ** const ps,
6473 bool enable_fast_literals)
6474 __attribute__ ((pure));
6475 inline static enum pvm_specialized_instruction_opcode
6476 pvm_recognize_specialized_instruction_ureloc (struct jitter_parameter ** const ps,
6477 bool enable_fast_literals)
6478 __attribute__ ((pure));
6479 inline static enum pvm_specialized_instruction_opcode
6480 pvm_recognize_specialized_instruction_write (struct jitter_parameter ** const ps,
6481 bool enable_fast_literals)
6482 __attribute__ ((pure));
6483
6484
6485 /* Recognizer function definitions. */
6486 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_addi(struct jitter_parameter ** const ps,bool enable_fast_literals)6487 pvm_recognize_specialized_instruction_addi (struct jitter_parameter ** const ps,
6488 bool enable_fast_literals)
6489 {
6490 /* The prefix is a full specialized instruction. We're done recognizing it. */
6491 return pvm_specialized_instruction_opcode_addi;
6492 }
6493
6494 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_addiu(struct jitter_parameter ** const ps,bool enable_fast_literals)6495 pvm_recognize_specialized_instruction_addiu (struct jitter_parameter ** const ps,
6496 bool enable_fast_literals)
6497 {
6498 /* The prefix is a full specialized instruction. We're done recognizing it. */
6499 return pvm_specialized_instruction_opcode_addiu;
6500 }
6501
6502 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_addl(struct jitter_parameter ** const ps,bool enable_fast_literals)6503 pvm_recognize_specialized_instruction_addl (struct jitter_parameter ** const ps,
6504 bool enable_fast_literals)
6505 {
6506 /* The prefix is a full specialized instruction. We're done recognizing it. */
6507 return pvm_specialized_instruction_opcode_addl;
6508 }
6509
6510 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_addlu(struct jitter_parameter ** const ps,bool enable_fast_literals)6511 pvm_recognize_specialized_instruction_addlu (struct jitter_parameter ** const ps,
6512 bool enable_fast_literals)
6513 {
6514 /* The prefix is a full specialized instruction. We're done recognizing it. */
6515 return pvm_specialized_instruction_opcode_addlu;
6516 }
6517
6518 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ains(struct jitter_parameter ** const ps,bool enable_fast_literals)6519 pvm_recognize_specialized_instruction_ains (struct jitter_parameter ** const ps,
6520 bool enable_fast_literals)
6521 {
6522 /* The prefix is a full specialized instruction. We're done recognizing it. */
6523 return pvm_specialized_instruction_opcode_ains;
6524 }
6525
6526 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_and(struct jitter_parameter ** const ps,bool enable_fast_literals)6527 pvm_recognize_specialized_instruction_and (struct jitter_parameter ** const ps,
6528 bool enable_fast_literals)
6529 {
6530 /* The prefix is a full specialized instruction. We're done recognizing it. */
6531 return pvm_specialized_instruction_opcode_and;
6532 }
6533
6534 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_aref(struct jitter_parameter ** const ps,bool enable_fast_literals)6535 pvm_recognize_specialized_instruction_aref (struct jitter_parameter ** const ps,
6536 bool enable_fast_literals)
6537 {
6538 /* The prefix is a full specialized instruction. We're done recognizing it. */
6539 return pvm_specialized_instruction_opcode_aref;
6540 }
6541
6542 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_arefo(struct jitter_parameter ** const ps,bool enable_fast_literals)6543 pvm_recognize_specialized_instruction_arefo (struct jitter_parameter ** const ps,
6544 bool enable_fast_literals)
6545 {
6546 /* The prefix is a full specialized instruction. We're done recognizing it. */
6547 return pvm_specialized_instruction_opcode_arefo;
6548 }
6549
6550 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_arem(struct jitter_parameter ** const ps,bool enable_fast_literals)6551 pvm_recognize_specialized_instruction_arem (struct jitter_parameter ** const ps,
6552 bool enable_fast_literals)
6553 {
6554 /* The prefix is a full specialized instruction. We're done recognizing it. */
6555 return pvm_specialized_instruction_opcode_arem;
6556 }
6557
6558 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_aset(struct jitter_parameter ** const ps,bool enable_fast_literals)6559 pvm_recognize_specialized_instruction_aset (struct jitter_parameter ** const ps,
6560 bool enable_fast_literals)
6561 {
6562 /* The prefix is a full specialized instruction. We're done recognizing it. */
6563 return pvm_specialized_instruction_opcode_aset;
6564 }
6565
6566 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_asettb(struct jitter_parameter ** const ps,bool enable_fast_literals)6567 pvm_recognize_specialized_instruction_asettb (struct jitter_parameter ** const ps,
6568 bool enable_fast_literals)
6569 {
6570 /* The prefix is a full specialized instruction. We're done recognizing it. */
6571 return pvm_specialized_instruction_opcode_asettb;
6572 }
6573
6574 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_atr(struct jitter_parameter ** const ps,bool enable_fast_literals)6575 pvm_recognize_specialized_instruction_atr (struct jitter_parameter ** const ps,
6576 bool enable_fast_literals)
6577 {
6578 /* The prefix is a full specialized instruction. We're done recognizing it. */
6579 return pvm_specialized_instruction_opcode_atr;
6580 }
6581
6582 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ba(struct jitter_parameter ** const ps,bool enable_fast_literals)6583 pvm_recognize_specialized_instruction_ba (struct jitter_parameter ** const ps,
6584 bool enable_fast_literals)
6585 {
6586 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
6587 if (((* ps)->type == jitter_parameter_type_label)
6588 && (res = pvm_recognize_specialized_instruction_ba__fR (ps + 1, enable_fast_literals)))
6589 goto done;
6590 done:
6591 return res;
6592 }
6593
6594 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ba__fR(struct jitter_parameter ** const ps,bool enable_fast_literals)6595 pvm_recognize_specialized_instruction_ba__fR (struct jitter_parameter ** const ps,
6596 bool enable_fast_literals)
6597 {
6598 /* The prefix is a full specialized instruction. We're done recognizing it. */
6599 return pvm_specialized_instruction_opcode_ba__fR;
6600 }
6601
6602 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bandi(struct jitter_parameter ** const ps,bool enable_fast_literals)6603 pvm_recognize_specialized_instruction_bandi (struct jitter_parameter ** const ps,
6604 bool enable_fast_literals)
6605 {
6606 /* The prefix is a full specialized instruction. We're done recognizing it. */
6607 return pvm_specialized_instruction_opcode_bandi;
6608 }
6609
6610 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bandiu(struct jitter_parameter ** const ps,bool enable_fast_literals)6611 pvm_recognize_specialized_instruction_bandiu (struct jitter_parameter ** const ps,
6612 bool enable_fast_literals)
6613 {
6614 /* The prefix is a full specialized instruction. We're done recognizing it. */
6615 return pvm_specialized_instruction_opcode_bandiu;
6616 }
6617
6618 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bandl(struct jitter_parameter ** const ps,bool enable_fast_literals)6619 pvm_recognize_specialized_instruction_bandl (struct jitter_parameter ** const ps,
6620 bool enable_fast_literals)
6621 {
6622 /* The prefix is a full specialized instruction. We're done recognizing it. */
6623 return pvm_specialized_instruction_opcode_bandl;
6624 }
6625
6626 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bandlu(struct jitter_parameter ** const ps,bool enable_fast_literals)6627 pvm_recognize_specialized_instruction_bandlu (struct jitter_parameter ** const ps,
6628 bool enable_fast_literals)
6629 {
6630 /* The prefix is a full specialized instruction. We're done recognizing it. */
6631 return pvm_specialized_instruction_opcode_bandlu;
6632 }
6633
6634 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_beghl(struct jitter_parameter ** const ps,bool enable_fast_literals)6635 pvm_recognize_specialized_instruction_beghl (struct jitter_parameter ** const ps,
6636 bool enable_fast_literals)
6637 {
6638 /* The prefix is a full specialized instruction. We're done recognizing it. */
6639 return pvm_specialized_instruction_opcode_beghl;
6640 }
6641
6642 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_begsc(struct jitter_parameter ** const ps,bool enable_fast_literals)6643 pvm_recognize_specialized_instruction_begsc (struct jitter_parameter ** const ps,
6644 bool enable_fast_literals)
6645 {
6646 /* The prefix is a full specialized instruction. We're done recognizing it. */
6647 return pvm_specialized_instruction_opcode_begsc;
6648 }
6649
6650 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bn(struct jitter_parameter ** const ps,bool enable_fast_literals)6651 pvm_recognize_specialized_instruction_bn (struct jitter_parameter ** const ps,
6652 bool enable_fast_literals)
6653 {
6654 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
6655 if (((* ps)->type == jitter_parameter_type_label)
6656 && (res = pvm_recognize_specialized_instruction_bn__fR (ps + 1, enable_fast_literals)))
6657 goto done;
6658 done:
6659 return res;
6660 }
6661
6662 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bn__fR(struct jitter_parameter ** const ps,bool enable_fast_literals)6663 pvm_recognize_specialized_instruction_bn__fR (struct jitter_parameter ** const ps,
6664 bool enable_fast_literals)
6665 {
6666 /* The prefix is a full specialized instruction. We're done recognizing it. */
6667 return pvm_specialized_instruction_opcode_bn__fR;
6668 }
6669
6670 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bnn(struct jitter_parameter ** const ps,bool enable_fast_literals)6671 pvm_recognize_specialized_instruction_bnn (struct jitter_parameter ** const ps,
6672 bool enable_fast_literals)
6673 {
6674 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
6675 if (((* ps)->type == jitter_parameter_type_label)
6676 && (res = pvm_recognize_specialized_instruction_bnn__fR (ps + 1, enable_fast_literals)))
6677 goto done;
6678 done:
6679 return res;
6680 }
6681
6682 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bnn__fR(struct jitter_parameter ** const ps,bool enable_fast_literals)6683 pvm_recognize_specialized_instruction_bnn__fR (struct jitter_parameter ** const ps,
6684 bool enable_fast_literals)
6685 {
6686 /* The prefix is a full specialized instruction. We're done recognizing it. */
6687 return pvm_specialized_instruction_opcode_bnn__fR;
6688 }
6689
6690 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bnoti(struct jitter_parameter ** const ps,bool enable_fast_literals)6691 pvm_recognize_specialized_instruction_bnoti (struct jitter_parameter ** const ps,
6692 bool enable_fast_literals)
6693 {
6694 /* The prefix is a full specialized instruction. We're done recognizing it. */
6695 return pvm_specialized_instruction_opcode_bnoti;
6696 }
6697
6698 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bnotiu(struct jitter_parameter ** const ps,bool enable_fast_literals)6699 pvm_recognize_specialized_instruction_bnotiu (struct jitter_parameter ** const ps,
6700 bool enable_fast_literals)
6701 {
6702 /* The prefix is a full specialized instruction. We're done recognizing it. */
6703 return pvm_specialized_instruction_opcode_bnotiu;
6704 }
6705
6706 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bnotl(struct jitter_parameter ** const ps,bool enable_fast_literals)6707 pvm_recognize_specialized_instruction_bnotl (struct jitter_parameter ** const ps,
6708 bool enable_fast_literals)
6709 {
6710 /* The prefix is a full specialized instruction. We're done recognizing it. */
6711 return pvm_specialized_instruction_opcode_bnotl;
6712 }
6713
6714 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bnotlu(struct jitter_parameter ** const ps,bool enable_fast_literals)6715 pvm_recognize_specialized_instruction_bnotlu (struct jitter_parameter ** const ps,
6716 bool enable_fast_literals)
6717 {
6718 /* The prefix is a full specialized instruction. We're done recognizing it. */
6719 return pvm_specialized_instruction_opcode_bnotlu;
6720 }
6721
6722 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bnzi(struct jitter_parameter ** const ps,bool enable_fast_literals)6723 pvm_recognize_specialized_instruction_bnzi (struct jitter_parameter ** const ps,
6724 bool enable_fast_literals)
6725 {
6726 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
6727 if (((* ps)->type == jitter_parameter_type_label)
6728 && (res = pvm_recognize_specialized_instruction_bnzi__fR (ps + 1, enable_fast_literals)))
6729 goto done;
6730 done:
6731 return res;
6732 }
6733
6734 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bnzi__fR(struct jitter_parameter ** const ps,bool enable_fast_literals)6735 pvm_recognize_specialized_instruction_bnzi__fR (struct jitter_parameter ** const ps,
6736 bool enable_fast_literals)
6737 {
6738 /* The prefix is a full specialized instruction. We're done recognizing it. */
6739 return pvm_specialized_instruction_opcode_bnzi__fR;
6740 }
6741
6742 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bnziu(struct jitter_parameter ** const ps,bool enable_fast_literals)6743 pvm_recognize_specialized_instruction_bnziu (struct jitter_parameter ** const ps,
6744 bool enable_fast_literals)
6745 {
6746 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
6747 if (((* ps)->type == jitter_parameter_type_label)
6748 && (res = pvm_recognize_specialized_instruction_bnziu__fR (ps + 1, enable_fast_literals)))
6749 goto done;
6750 done:
6751 return res;
6752 }
6753
6754 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bnziu__fR(struct jitter_parameter ** const ps,bool enable_fast_literals)6755 pvm_recognize_specialized_instruction_bnziu__fR (struct jitter_parameter ** const ps,
6756 bool enable_fast_literals)
6757 {
6758 /* The prefix is a full specialized instruction. We're done recognizing it. */
6759 return pvm_specialized_instruction_opcode_bnziu__fR;
6760 }
6761
6762 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bnzl(struct jitter_parameter ** const ps,bool enable_fast_literals)6763 pvm_recognize_specialized_instruction_bnzl (struct jitter_parameter ** const ps,
6764 bool enable_fast_literals)
6765 {
6766 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
6767 if (((* ps)->type == jitter_parameter_type_label)
6768 && (res = pvm_recognize_specialized_instruction_bnzl__fR (ps + 1, enable_fast_literals)))
6769 goto done;
6770 done:
6771 return res;
6772 }
6773
6774 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bnzl__fR(struct jitter_parameter ** const ps,bool enable_fast_literals)6775 pvm_recognize_specialized_instruction_bnzl__fR (struct jitter_parameter ** const ps,
6776 bool enable_fast_literals)
6777 {
6778 /* The prefix is a full specialized instruction. We're done recognizing it. */
6779 return pvm_specialized_instruction_opcode_bnzl__fR;
6780 }
6781
6782 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bnzlu(struct jitter_parameter ** const ps,bool enable_fast_literals)6783 pvm_recognize_specialized_instruction_bnzlu (struct jitter_parameter ** const ps,
6784 bool enable_fast_literals)
6785 {
6786 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
6787 if (((* ps)->type == jitter_parameter_type_label)
6788 && (res = pvm_recognize_specialized_instruction_bnzlu__fR (ps + 1, enable_fast_literals)))
6789 goto done;
6790 done:
6791 return res;
6792 }
6793
6794 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bnzlu__fR(struct jitter_parameter ** const ps,bool enable_fast_literals)6795 pvm_recognize_specialized_instruction_bnzlu__fR (struct jitter_parameter ** const ps,
6796 bool enable_fast_literals)
6797 {
6798 /* The prefix is a full specialized instruction. We're done recognizing it. */
6799 return pvm_specialized_instruction_opcode_bnzlu__fR;
6800 }
6801
6802 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bori(struct jitter_parameter ** const ps,bool enable_fast_literals)6803 pvm_recognize_specialized_instruction_bori (struct jitter_parameter ** const ps,
6804 bool enable_fast_literals)
6805 {
6806 /* The prefix is a full specialized instruction. We're done recognizing it. */
6807 return pvm_specialized_instruction_opcode_bori;
6808 }
6809
6810 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_boriu(struct jitter_parameter ** const ps,bool enable_fast_literals)6811 pvm_recognize_specialized_instruction_boriu (struct jitter_parameter ** const ps,
6812 bool enable_fast_literals)
6813 {
6814 /* The prefix is a full specialized instruction. We're done recognizing it. */
6815 return pvm_specialized_instruction_opcode_boriu;
6816 }
6817
6818 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_borl(struct jitter_parameter ** const ps,bool enable_fast_literals)6819 pvm_recognize_specialized_instruction_borl (struct jitter_parameter ** const ps,
6820 bool enable_fast_literals)
6821 {
6822 /* The prefix is a full specialized instruction. We're done recognizing it. */
6823 return pvm_specialized_instruction_opcode_borl;
6824 }
6825
6826 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_borlu(struct jitter_parameter ** const ps,bool enable_fast_literals)6827 pvm_recognize_specialized_instruction_borlu (struct jitter_parameter ** const ps,
6828 bool enable_fast_literals)
6829 {
6830 /* The prefix is a full specialized instruction. We're done recognizing it. */
6831 return pvm_specialized_instruction_opcode_borlu;
6832 }
6833
6834 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bsli(struct jitter_parameter ** const ps,bool enable_fast_literals)6835 pvm_recognize_specialized_instruction_bsli (struct jitter_parameter ** const ps,
6836 bool enable_fast_literals)
6837 {
6838 /* The prefix is a full specialized instruction. We're done recognizing it. */
6839 return pvm_specialized_instruction_opcode_bsli;
6840 }
6841
6842 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bsliu(struct jitter_parameter ** const ps,bool enable_fast_literals)6843 pvm_recognize_specialized_instruction_bsliu (struct jitter_parameter ** const ps,
6844 bool enable_fast_literals)
6845 {
6846 /* The prefix is a full specialized instruction. We're done recognizing it. */
6847 return pvm_specialized_instruction_opcode_bsliu;
6848 }
6849
6850 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bsll(struct jitter_parameter ** const ps,bool enable_fast_literals)6851 pvm_recognize_specialized_instruction_bsll (struct jitter_parameter ** const ps,
6852 bool enable_fast_literals)
6853 {
6854 /* The prefix is a full specialized instruction. We're done recognizing it. */
6855 return pvm_specialized_instruction_opcode_bsll;
6856 }
6857
6858 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bsllu(struct jitter_parameter ** const ps,bool enable_fast_literals)6859 pvm_recognize_specialized_instruction_bsllu (struct jitter_parameter ** const ps,
6860 bool enable_fast_literals)
6861 {
6862 /* The prefix is a full specialized instruction. We're done recognizing it. */
6863 return pvm_specialized_instruction_opcode_bsllu;
6864 }
6865
6866 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bsri(struct jitter_parameter ** const ps,bool enable_fast_literals)6867 pvm_recognize_specialized_instruction_bsri (struct jitter_parameter ** const ps,
6868 bool enable_fast_literals)
6869 {
6870 /* The prefix is a full specialized instruction. We're done recognizing it. */
6871 return pvm_specialized_instruction_opcode_bsri;
6872 }
6873
6874 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bsriu(struct jitter_parameter ** const ps,bool enable_fast_literals)6875 pvm_recognize_specialized_instruction_bsriu (struct jitter_parameter ** const ps,
6876 bool enable_fast_literals)
6877 {
6878 /* The prefix is a full specialized instruction. We're done recognizing it. */
6879 return pvm_specialized_instruction_opcode_bsriu;
6880 }
6881
6882 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bsrl(struct jitter_parameter ** const ps,bool enable_fast_literals)6883 pvm_recognize_specialized_instruction_bsrl (struct jitter_parameter ** const ps,
6884 bool enable_fast_literals)
6885 {
6886 /* The prefix is a full specialized instruction. We're done recognizing it. */
6887 return pvm_specialized_instruction_opcode_bsrl;
6888 }
6889
6890 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bsrlu(struct jitter_parameter ** const ps,bool enable_fast_literals)6891 pvm_recognize_specialized_instruction_bsrlu (struct jitter_parameter ** const ps,
6892 bool enable_fast_literals)
6893 {
6894 /* The prefix is a full specialized instruction. We're done recognizing it. */
6895 return pvm_specialized_instruction_opcode_bsrlu;
6896 }
6897
6898 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bxori(struct jitter_parameter ** const ps,bool enable_fast_literals)6899 pvm_recognize_specialized_instruction_bxori (struct jitter_parameter ** const ps,
6900 bool enable_fast_literals)
6901 {
6902 /* The prefix is a full specialized instruction. We're done recognizing it. */
6903 return pvm_specialized_instruction_opcode_bxori;
6904 }
6905
6906 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bxoriu(struct jitter_parameter ** const ps,bool enable_fast_literals)6907 pvm_recognize_specialized_instruction_bxoriu (struct jitter_parameter ** const ps,
6908 bool enable_fast_literals)
6909 {
6910 /* The prefix is a full specialized instruction. We're done recognizing it. */
6911 return pvm_specialized_instruction_opcode_bxoriu;
6912 }
6913
6914 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bxorl(struct jitter_parameter ** const ps,bool enable_fast_literals)6915 pvm_recognize_specialized_instruction_bxorl (struct jitter_parameter ** const ps,
6916 bool enable_fast_literals)
6917 {
6918 /* The prefix is a full specialized instruction. We're done recognizing it. */
6919 return pvm_specialized_instruction_opcode_bxorl;
6920 }
6921
6922 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bxorlu(struct jitter_parameter ** const ps,bool enable_fast_literals)6923 pvm_recognize_specialized_instruction_bxorlu (struct jitter_parameter ** const ps,
6924 bool enable_fast_literals)
6925 {
6926 /* The prefix is a full specialized instruction. We're done recognizing it. */
6927 return pvm_specialized_instruction_opcode_bxorlu;
6928 }
6929
6930 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bzi(struct jitter_parameter ** const ps,bool enable_fast_literals)6931 pvm_recognize_specialized_instruction_bzi (struct jitter_parameter ** const ps,
6932 bool enable_fast_literals)
6933 {
6934 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
6935 if (((* ps)->type == jitter_parameter_type_label)
6936 && (res = pvm_recognize_specialized_instruction_bzi__fR (ps + 1, enable_fast_literals)))
6937 goto done;
6938 done:
6939 return res;
6940 }
6941
6942 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bzi__fR(struct jitter_parameter ** const ps,bool enable_fast_literals)6943 pvm_recognize_specialized_instruction_bzi__fR (struct jitter_parameter ** const ps,
6944 bool enable_fast_literals)
6945 {
6946 /* The prefix is a full specialized instruction. We're done recognizing it. */
6947 return pvm_specialized_instruction_opcode_bzi__fR;
6948 }
6949
6950 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bziu(struct jitter_parameter ** const ps,bool enable_fast_literals)6951 pvm_recognize_specialized_instruction_bziu (struct jitter_parameter ** const ps,
6952 bool enable_fast_literals)
6953 {
6954 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
6955 if (((* ps)->type == jitter_parameter_type_label)
6956 && (res = pvm_recognize_specialized_instruction_bziu__fR (ps + 1, enable_fast_literals)))
6957 goto done;
6958 done:
6959 return res;
6960 }
6961
6962 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bziu__fR(struct jitter_parameter ** const ps,bool enable_fast_literals)6963 pvm_recognize_specialized_instruction_bziu__fR (struct jitter_parameter ** const ps,
6964 bool enable_fast_literals)
6965 {
6966 /* The prefix is a full specialized instruction. We're done recognizing it. */
6967 return pvm_specialized_instruction_opcode_bziu__fR;
6968 }
6969
6970 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bzl(struct jitter_parameter ** const ps,bool enable_fast_literals)6971 pvm_recognize_specialized_instruction_bzl (struct jitter_parameter ** const ps,
6972 bool enable_fast_literals)
6973 {
6974 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
6975 if (((* ps)->type == jitter_parameter_type_label)
6976 && (res = pvm_recognize_specialized_instruction_bzl__fR (ps + 1, enable_fast_literals)))
6977 goto done;
6978 done:
6979 return res;
6980 }
6981
6982 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bzl__fR(struct jitter_parameter ** const ps,bool enable_fast_literals)6983 pvm_recognize_specialized_instruction_bzl__fR (struct jitter_parameter ** const ps,
6984 bool enable_fast_literals)
6985 {
6986 /* The prefix is a full specialized instruction. We're done recognizing it. */
6987 return pvm_specialized_instruction_opcode_bzl__fR;
6988 }
6989
6990 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bzlu(struct jitter_parameter ** const ps,bool enable_fast_literals)6991 pvm_recognize_specialized_instruction_bzlu (struct jitter_parameter ** const ps,
6992 bool enable_fast_literals)
6993 {
6994 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
6995 if (((* ps)->type == jitter_parameter_type_label)
6996 && (res = pvm_recognize_specialized_instruction_bzlu__fR (ps + 1, enable_fast_literals)))
6997 goto done;
6998 done:
6999 return res;
7000 }
7001
7002 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_bzlu__fR(struct jitter_parameter ** const ps,bool enable_fast_literals)7003 pvm_recognize_specialized_instruction_bzlu__fR (struct jitter_parameter ** const ps,
7004 bool enable_fast_literals)
7005 {
7006 /* The prefix is a full specialized instruction. We're done recognizing it. */
7007 return pvm_specialized_instruction_opcode_bzlu__fR;
7008 }
7009
7010 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_call(struct jitter_parameter ** const ps,bool enable_fast_literals)7011 pvm_recognize_specialized_instruction_call (struct jitter_parameter ** const ps,
7012 bool enable_fast_literals)
7013 {
7014 /* The prefix is a full specialized instruction. We're done recognizing it. */
7015 return pvm_specialized_instruction_opcode_call__retR;
7016 }
7017
7018 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_canary(struct jitter_parameter ** const ps,bool enable_fast_literals)7019 pvm_recognize_specialized_instruction_canary (struct jitter_parameter ** const ps,
7020 bool enable_fast_literals)
7021 {
7022 /* The prefix is a full specialized instruction. We're done recognizing it. */
7023 return pvm_specialized_instruction_opcode_canary;
7024 }
7025
7026 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_close(struct jitter_parameter ** const ps,bool enable_fast_literals)7027 pvm_recognize_specialized_instruction_close (struct jitter_parameter ** const ps,
7028 bool enable_fast_literals)
7029 {
7030 /* The prefix is a full specialized instruction. We're done recognizing it. */
7031 return pvm_specialized_instruction_opcode_close;
7032 }
7033
7034 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ctos(struct jitter_parameter ** const ps,bool enable_fast_literals)7035 pvm_recognize_specialized_instruction_ctos (struct jitter_parameter ** const ps,
7036 bool enable_fast_literals)
7037 {
7038 /* The prefix is a full specialized instruction. We're done recognizing it. */
7039 return pvm_specialized_instruction_opcode_ctos;
7040 }
7041
7042 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_disas(struct jitter_parameter ** const ps,bool enable_fast_literals)7043 pvm_recognize_specialized_instruction_disas (struct jitter_parameter ** const ps,
7044 bool enable_fast_literals)
7045 {
7046 /* The prefix is a full specialized instruction. We're done recognizing it. */
7047 return pvm_specialized_instruction_opcode_disas;
7048 }
7049
7050 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_divi(struct jitter_parameter ** const ps,bool enable_fast_literals)7051 pvm_recognize_specialized_instruction_divi (struct jitter_parameter ** const ps,
7052 bool enable_fast_literals)
7053 {
7054 /* The prefix is a full specialized instruction. We're done recognizing it. */
7055 return pvm_specialized_instruction_opcode_divi;
7056 }
7057
7058 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_diviu(struct jitter_parameter ** const ps,bool enable_fast_literals)7059 pvm_recognize_specialized_instruction_diviu (struct jitter_parameter ** const ps,
7060 bool enable_fast_literals)
7061 {
7062 /* The prefix is a full specialized instruction. We're done recognizing it. */
7063 return pvm_specialized_instruction_opcode_diviu;
7064 }
7065
7066 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_divl(struct jitter_parameter ** const ps,bool enable_fast_literals)7067 pvm_recognize_specialized_instruction_divl (struct jitter_parameter ** const ps,
7068 bool enable_fast_literals)
7069 {
7070 /* The prefix is a full specialized instruction. We're done recognizing it. */
7071 return pvm_specialized_instruction_opcode_divl;
7072 }
7073
7074 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_divlu(struct jitter_parameter ** const ps,bool enable_fast_literals)7075 pvm_recognize_specialized_instruction_divlu (struct jitter_parameter ** const ps,
7076 bool enable_fast_literals)
7077 {
7078 /* The prefix is a full specialized instruction. We're done recognizing it. */
7079 return pvm_specialized_instruction_opcode_divlu;
7080 }
7081
7082 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_drop(struct jitter_parameter ** const ps,bool enable_fast_literals)7083 pvm_recognize_specialized_instruction_drop (struct jitter_parameter ** const ps,
7084 bool enable_fast_literals)
7085 {
7086 /* The prefix is a full specialized instruction. We're done recognizing it. */
7087 return pvm_specialized_instruction_opcode_drop;
7088 }
7089
7090 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_drop2(struct jitter_parameter ** const ps,bool enable_fast_literals)7091 pvm_recognize_specialized_instruction_drop2 (struct jitter_parameter ** const ps,
7092 bool enable_fast_literals)
7093 {
7094 /* The prefix is a full specialized instruction. We're done recognizing it. */
7095 return pvm_specialized_instruction_opcode_drop2;
7096 }
7097
7098 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_drop3(struct jitter_parameter ** const ps,bool enable_fast_literals)7099 pvm_recognize_specialized_instruction_drop3 (struct jitter_parameter ** const ps,
7100 bool enable_fast_literals)
7101 {
7102 /* The prefix is a full specialized instruction. We're done recognizing it. */
7103 return pvm_specialized_instruction_opcode_drop3;
7104 }
7105
7106 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_drop4(struct jitter_parameter ** const ps,bool enable_fast_literals)7107 pvm_recognize_specialized_instruction_drop4 (struct jitter_parameter ** const ps,
7108 bool enable_fast_literals)
7109 {
7110 /* The prefix is a full specialized instruction. We're done recognizing it. */
7111 return pvm_specialized_instruction_opcode_drop4;
7112 }
7113
7114 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_duc(struct jitter_parameter ** const ps,bool enable_fast_literals)7115 pvm_recognize_specialized_instruction_duc (struct jitter_parameter ** const ps,
7116 bool enable_fast_literals)
7117 {
7118 /* The prefix is a full specialized instruction. We're done recognizing it. */
7119 return pvm_specialized_instruction_opcode_duc;
7120 }
7121
7122 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_dup(struct jitter_parameter ** const ps,bool enable_fast_literals)7123 pvm_recognize_specialized_instruction_dup (struct jitter_parameter ** const ps,
7124 bool enable_fast_literals)
7125 {
7126 /* The prefix is a full specialized instruction. We're done recognizing it. */
7127 return pvm_specialized_instruction_opcode_dup;
7128 }
7129
7130 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_endhl(struct jitter_parameter ** const ps,bool enable_fast_literals)7131 pvm_recognize_specialized_instruction_endhl (struct jitter_parameter ** const ps,
7132 bool enable_fast_literals)
7133 {
7134 /* The prefix is a full specialized instruction. We're done recognizing it. */
7135 return pvm_specialized_instruction_opcode_endhl;
7136 }
7137
7138 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_endsc(struct jitter_parameter ** const ps,bool enable_fast_literals)7139 pvm_recognize_specialized_instruction_endsc (struct jitter_parameter ** const ps,
7140 bool enable_fast_literals)
7141 {
7142 /* The prefix is a full specialized instruction. We're done recognizing it. */
7143 return pvm_specialized_instruction_opcode_endsc;
7144 }
7145
7146 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_eqi(struct jitter_parameter ** const ps,bool enable_fast_literals)7147 pvm_recognize_specialized_instruction_eqi (struct jitter_parameter ** const ps,
7148 bool enable_fast_literals)
7149 {
7150 /* The prefix is a full specialized instruction. We're done recognizing it. */
7151 return pvm_specialized_instruction_opcode_eqi;
7152 }
7153
7154 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_eqiu(struct jitter_parameter ** const ps,bool enable_fast_literals)7155 pvm_recognize_specialized_instruction_eqiu (struct jitter_parameter ** const ps,
7156 bool enable_fast_literals)
7157 {
7158 /* The prefix is a full specialized instruction. We're done recognizing it. */
7159 return pvm_specialized_instruction_opcode_eqiu;
7160 }
7161
7162 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_eql(struct jitter_parameter ** const ps,bool enable_fast_literals)7163 pvm_recognize_specialized_instruction_eql (struct jitter_parameter ** const ps,
7164 bool enable_fast_literals)
7165 {
7166 /* The prefix is a full specialized instruction. We're done recognizing it. */
7167 return pvm_specialized_instruction_opcode_eql;
7168 }
7169
7170 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_eqlu(struct jitter_parameter ** const ps,bool enable_fast_literals)7171 pvm_recognize_specialized_instruction_eqlu (struct jitter_parameter ** const ps,
7172 bool enable_fast_literals)
7173 {
7174 /* The prefix is a full specialized instruction. We're done recognizing it. */
7175 return pvm_specialized_instruction_opcode_eqlu;
7176 }
7177
7178 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_eqs(struct jitter_parameter ** const ps,bool enable_fast_literals)7179 pvm_recognize_specialized_instruction_eqs (struct jitter_parameter ** const ps,
7180 bool enable_fast_literals)
7181 {
7182 /* The prefix is a full specialized instruction. We're done recognizing it. */
7183 return pvm_specialized_instruction_opcode_eqs;
7184 }
7185
7186 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_exit(struct jitter_parameter ** const ps,bool enable_fast_literals)7187 pvm_recognize_specialized_instruction_exit (struct jitter_parameter ** const ps,
7188 bool enable_fast_literals)
7189 {
7190 /* The prefix is a full specialized instruction. We're done recognizing it. */
7191 return pvm_specialized_instruction_opcode_exit;
7192 }
7193
7194 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_exitvm(struct jitter_parameter ** const ps,bool enable_fast_literals)7195 pvm_recognize_specialized_instruction_exitvm (struct jitter_parameter ** const ps,
7196 bool enable_fast_literals)
7197 {
7198 /* The prefix is a full specialized instruction. We're done recognizing it. */
7199 return pvm_specialized_instruction_opcode_exitvm;
7200 }
7201
7202 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_flush(struct jitter_parameter ** const ps,bool enable_fast_literals)7203 pvm_recognize_specialized_instruction_flush (struct jitter_parameter ** const ps,
7204 bool enable_fast_literals)
7205 {
7206 /* The prefix is a full specialized instruction. We're done recognizing it. */
7207 return pvm_specialized_instruction_opcode_flush;
7208 }
7209
7210 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_fromr(struct jitter_parameter ** const ps,bool enable_fast_literals)7211 pvm_recognize_specialized_instruction_fromr (struct jitter_parameter ** const ps,
7212 bool enable_fast_literals)
7213 {
7214 /* The prefix is a full specialized instruction. We're done recognizing it. */
7215 return pvm_specialized_instruction_opcode_fromr;
7216 }
7217
7218 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_gei(struct jitter_parameter ** const ps,bool enable_fast_literals)7219 pvm_recognize_specialized_instruction_gei (struct jitter_parameter ** const ps,
7220 bool enable_fast_literals)
7221 {
7222 /* The prefix is a full specialized instruction. We're done recognizing it. */
7223 return pvm_specialized_instruction_opcode_gei;
7224 }
7225
7226 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_geiu(struct jitter_parameter ** const ps,bool enable_fast_literals)7227 pvm_recognize_specialized_instruction_geiu (struct jitter_parameter ** const ps,
7228 bool enable_fast_literals)
7229 {
7230 /* The prefix is a full specialized instruction. We're done recognizing it. */
7231 return pvm_specialized_instruction_opcode_geiu;
7232 }
7233
7234 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_gel(struct jitter_parameter ** const ps,bool enable_fast_literals)7235 pvm_recognize_specialized_instruction_gel (struct jitter_parameter ** const ps,
7236 bool enable_fast_literals)
7237 {
7238 /* The prefix is a full specialized instruction. We're done recognizing it. */
7239 return pvm_specialized_instruction_opcode_gel;
7240 }
7241
7242 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_gelu(struct jitter_parameter ** const ps,bool enable_fast_literals)7243 pvm_recognize_specialized_instruction_gelu (struct jitter_parameter ** const ps,
7244 bool enable_fast_literals)
7245 {
7246 /* The prefix is a full specialized instruction. We're done recognizing it. */
7247 return pvm_specialized_instruction_opcode_gelu;
7248 }
7249
7250 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ges(struct jitter_parameter ** const ps,bool enable_fast_literals)7251 pvm_recognize_specialized_instruction_ges (struct jitter_parameter ** const ps,
7252 bool enable_fast_literals)
7253 {
7254 /* The prefix is a full specialized instruction. We're done recognizing it. */
7255 return pvm_specialized_instruction_opcode_ges;
7256 }
7257
7258 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_getenv(struct jitter_parameter ** const ps,bool enable_fast_literals)7259 pvm_recognize_specialized_instruction_getenv (struct jitter_parameter ** const ps,
7260 bool enable_fast_literals)
7261 {
7262 /* The prefix is a full specialized instruction. We're done recognizing it. */
7263 return pvm_specialized_instruction_opcode_getenv;
7264 }
7265
7266 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_gti(struct jitter_parameter ** const ps,bool enable_fast_literals)7267 pvm_recognize_specialized_instruction_gti (struct jitter_parameter ** const ps,
7268 bool enable_fast_literals)
7269 {
7270 /* The prefix is a full specialized instruction. We're done recognizing it. */
7271 return pvm_specialized_instruction_opcode_gti;
7272 }
7273
7274 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_gtiu(struct jitter_parameter ** const ps,bool enable_fast_literals)7275 pvm_recognize_specialized_instruction_gtiu (struct jitter_parameter ** const ps,
7276 bool enable_fast_literals)
7277 {
7278 /* The prefix is a full specialized instruction. We're done recognizing it. */
7279 return pvm_specialized_instruction_opcode_gtiu;
7280 }
7281
7282 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_gtl(struct jitter_parameter ** const ps,bool enable_fast_literals)7283 pvm_recognize_specialized_instruction_gtl (struct jitter_parameter ** const ps,
7284 bool enable_fast_literals)
7285 {
7286 /* The prefix is a full specialized instruction. We're done recognizing it. */
7287 return pvm_specialized_instruction_opcode_gtl;
7288 }
7289
7290 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_gtlu(struct jitter_parameter ** const ps,bool enable_fast_literals)7291 pvm_recognize_specialized_instruction_gtlu (struct jitter_parameter ** const ps,
7292 bool enable_fast_literals)
7293 {
7294 /* The prefix is a full specialized instruction. We're done recognizing it. */
7295 return pvm_specialized_instruction_opcode_gtlu;
7296 }
7297
7298 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_gts(struct jitter_parameter ** const ps,bool enable_fast_literals)7299 pvm_recognize_specialized_instruction_gts (struct jitter_parameter ** const ps,
7300 bool enable_fast_literals)
7301 {
7302 /* The prefix is a full specialized instruction. We're done recognizing it. */
7303 return pvm_specialized_instruction_opcode_gts;
7304 }
7305
7306 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_indent(struct jitter_parameter ** const ps,bool enable_fast_literals)7307 pvm_recognize_specialized_instruction_indent (struct jitter_parameter ** const ps,
7308 bool enable_fast_literals)
7309 {
7310 /* The prefix is a full specialized instruction. We're done recognizing it. */
7311 return pvm_specialized_instruction_opcode_indent;
7312 }
7313
7314 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_iogetb(struct jitter_parameter ** const ps,bool enable_fast_literals)7315 pvm_recognize_specialized_instruction_iogetb (struct jitter_parameter ** const ps,
7316 bool enable_fast_literals)
7317 {
7318 /* The prefix is a full specialized instruction. We're done recognizing it. */
7319 return pvm_specialized_instruction_opcode_iogetb;
7320 }
7321
7322 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_iosetb(struct jitter_parameter ** const ps,bool enable_fast_literals)7323 pvm_recognize_specialized_instruction_iosetb (struct jitter_parameter ** const ps,
7324 bool enable_fast_literals)
7325 {
7326 /* The prefix is a full specialized instruction. We're done recognizing it. */
7327 return pvm_specialized_instruction_opcode_iosetb;
7328 }
7329
7330 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_iosize(struct jitter_parameter ** const ps,bool enable_fast_literals)7331 pvm_recognize_specialized_instruction_iosize (struct jitter_parameter ** const ps,
7332 bool enable_fast_literals)
7333 {
7334 /* The prefix is a full specialized instruction. We're done recognizing it. */
7335 return pvm_specialized_instruction_opcode_iosize;
7336 }
7337
7338 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_isa(struct jitter_parameter ** const ps,bool enable_fast_literals)7339 pvm_recognize_specialized_instruction_isa (struct jitter_parameter ** const ps,
7340 bool enable_fast_literals)
7341 {
7342 /* The prefix is a full specialized instruction. We're done recognizing it. */
7343 return pvm_specialized_instruction_opcode_isa;
7344 }
7345
7346 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_itoi(struct jitter_parameter ** const ps,bool enable_fast_literals)7347 pvm_recognize_specialized_instruction_itoi (struct jitter_parameter ** const ps,
7348 bool enable_fast_literals)
7349 {
7350 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
7351 if (((* ps)->type == jitter_parameter_type_literal)
7352 && (res = pvm_recognize_specialized_instruction_itoi__nR (ps + 1, enable_fast_literals)))
7353 goto done;
7354 done:
7355 return res;
7356 }
7357
7358 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_itoi__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)7359 pvm_recognize_specialized_instruction_itoi__nR (struct jitter_parameter ** const ps,
7360 bool enable_fast_literals)
7361 {
7362 /* The prefix is a full specialized instruction. We're done recognizing it. */
7363 return pvm_specialized_instruction_opcode_itoi__nR;
7364 }
7365
7366 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_itoiu(struct jitter_parameter ** const ps,bool enable_fast_literals)7367 pvm_recognize_specialized_instruction_itoiu (struct jitter_parameter ** const ps,
7368 bool enable_fast_literals)
7369 {
7370 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
7371 if (((* ps)->type == jitter_parameter_type_literal)
7372 && (res = pvm_recognize_specialized_instruction_itoiu__nR (ps + 1, enable_fast_literals)))
7373 goto done;
7374 done:
7375 return res;
7376 }
7377
7378 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_itoiu__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)7379 pvm_recognize_specialized_instruction_itoiu__nR (struct jitter_parameter ** const ps,
7380 bool enable_fast_literals)
7381 {
7382 /* The prefix is a full specialized instruction. We're done recognizing it. */
7383 return pvm_specialized_instruction_opcode_itoiu__nR;
7384 }
7385
7386 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_itol(struct jitter_parameter ** const ps,bool enable_fast_literals)7387 pvm_recognize_specialized_instruction_itol (struct jitter_parameter ** const ps,
7388 bool enable_fast_literals)
7389 {
7390 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
7391 if (((* ps)->type == jitter_parameter_type_literal)
7392 && (res = pvm_recognize_specialized_instruction_itol__nR (ps + 1, enable_fast_literals)))
7393 goto done;
7394 done:
7395 return res;
7396 }
7397
7398 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_itol__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)7399 pvm_recognize_specialized_instruction_itol__nR (struct jitter_parameter ** const ps,
7400 bool enable_fast_literals)
7401 {
7402 /* The prefix is a full specialized instruction. We're done recognizing it. */
7403 return pvm_specialized_instruction_opcode_itol__nR;
7404 }
7405
7406 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_itolu(struct jitter_parameter ** const ps,bool enable_fast_literals)7407 pvm_recognize_specialized_instruction_itolu (struct jitter_parameter ** const ps,
7408 bool enable_fast_literals)
7409 {
7410 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
7411 if (((* ps)->type == jitter_parameter_type_literal)
7412 && (res = pvm_recognize_specialized_instruction_itolu__nR (ps + 1, enable_fast_literals)))
7413 goto done;
7414 done:
7415 return res;
7416 }
7417
7418 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_itolu__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)7419 pvm_recognize_specialized_instruction_itolu__nR (struct jitter_parameter ** const ps,
7420 bool enable_fast_literals)
7421 {
7422 /* The prefix is a full specialized instruction. We're done recognizing it. */
7423 return pvm_specialized_instruction_opcode_itolu__nR;
7424 }
7425
7426 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_iutoi(struct jitter_parameter ** const ps,bool enable_fast_literals)7427 pvm_recognize_specialized_instruction_iutoi (struct jitter_parameter ** const ps,
7428 bool enable_fast_literals)
7429 {
7430 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
7431 if (((* ps)->type == jitter_parameter_type_literal)
7432 && (res = pvm_recognize_specialized_instruction_iutoi__nR (ps + 1, enable_fast_literals)))
7433 goto done;
7434 done:
7435 return res;
7436 }
7437
7438 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_iutoi__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)7439 pvm_recognize_specialized_instruction_iutoi__nR (struct jitter_parameter ** const ps,
7440 bool enable_fast_literals)
7441 {
7442 /* The prefix is a full specialized instruction. We're done recognizing it. */
7443 return pvm_specialized_instruction_opcode_iutoi__nR;
7444 }
7445
7446 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_iutoiu(struct jitter_parameter ** const ps,bool enable_fast_literals)7447 pvm_recognize_specialized_instruction_iutoiu (struct jitter_parameter ** const ps,
7448 bool enable_fast_literals)
7449 {
7450 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
7451 if (((* ps)->type == jitter_parameter_type_literal)
7452 && (res = pvm_recognize_specialized_instruction_iutoiu__nR (ps + 1, enable_fast_literals)))
7453 goto done;
7454 done:
7455 return res;
7456 }
7457
7458 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_iutoiu__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)7459 pvm_recognize_specialized_instruction_iutoiu__nR (struct jitter_parameter ** const ps,
7460 bool enable_fast_literals)
7461 {
7462 /* The prefix is a full specialized instruction. We're done recognizing it. */
7463 return pvm_specialized_instruction_opcode_iutoiu__nR;
7464 }
7465
7466 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_iutol(struct jitter_parameter ** const ps,bool enable_fast_literals)7467 pvm_recognize_specialized_instruction_iutol (struct jitter_parameter ** const ps,
7468 bool enable_fast_literals)
7469 {
7470 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
7471 if (((* ps)->type == jitter_parameter_type_literal)
7472 && (res = pvm_recognize_specialized_instruction_iutol__nR (ps + 1, enable_fast_literals)))
7473 goto done;
7474 done:
7475 return res;
7476 }
7477
7478 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_iutol__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)7479 pvm_recognize_specialized_instruction_iutol__nR (struct jitter_parameter ** const ps,
7480 bool enable_fast_literals)
7481 {
7482 /* The prefix is a full specialized instruction. We're done recognizing it. */
7483 return pvm_specialized_instruction_opcode_iutol__nR;
7484 }
7485
7486 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_iutolu(struct jitter_parameter ** const ps,bool enable_fast_literals)7487 pvm_recognize_specialized_instruction_iutolu (struct jitter_parameter ** const ps,
7488 bool enable_fast_literals)
7489 {
7490 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
7491 if (((* ps)->type == jitter_parameter_type_literal)
7492 && (res = pvm_recognize_specialized_instruction_iutolu__nR (ps + 1, enable_fast_literals)))
7493 goto done;
7494 done:
7495 return res;
7496 }
7497
7498 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_iutolu__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)7499 pvm_recognize_specialized_instruction_iutolu__nR (struct jitter_parameter ** const ps,
7500 bool enable_fast_literals)
7501 {
7502 /* The prefix is a full specialized instruction. We're done recognizing it. */
7503 return pvm_specialized_instruction_opcode_iutolu__nR;
7504 }
7505
7506 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_lei(struct jitter_parameter ** const ps,bool enable_fast_literals)7507 pvm_recognize_specialized_instruction_lei (struct jitter_parameter ** const ps,
7508 bool enable_fast_literals)
7509 {
7510 /* The prefix is a full specialized instruction. We're done recognizing it. */
7511 return pvm_specialized_instruction_opcode_lei;
7512 }
7513
7514 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_leiu(struct jitter_parameter ** const ps,bool enable_fast_literals)7515 pvm_recognize_specialized_instruction_leiu (struct jitter_parameter ** const ps,
7516 bool enable_fast_literals)
7517 {
7518 /* The prefix is a full specialized instruction. We're done recognizing it. */
7519 return pvm_specialized_instruction_opcode_leiu;
7520 }
7521
7522 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_lel(struct jitter_parameter ** const ps,bool enable_fast_literals)7523 pvm_recognize_specialized_instruction_lel (struct jitter_parameter ** const ps,
7524 bool enable_fast_literals)
7525 {
7526 /* The prefix is a full specialized instruction. We're done recognizing it. */
7527 return pvm_specialized_instruction_opcode_lel;
7528 }
7529
7530 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_lelu(struct jitter_parameter ** const ps,bool enable_fast_literals)7531 pvm_recognize_specialized_instruction_lelu (struct jitter_parameter ** const ps,
7532 bool enable_fast_literals)
7533 {
7534 /* The prefix is a full specialized instruction. We're done recognizing it. */
7535 return pvm_specialized_instruction_opcode_lelu;
7536 }
7537
7538 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_les(struct jitter_parameter ** const ps,bool enable_fast_literals)7539 pvm_recognize_specialized_instruction_les (struct jitter_parameter ** const ps,
7540 bool enable_fast_literals)
7541 {
7542 /* The prefix is a full specialized instruction. We're done recognizing it. */
7543 return pvm_specialized_instruction_opcode_les;
7544 }
7545
7546 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_lti(struct jitter_parameter ** const ps,bool enable_fast_literals)7547 pvm_recognize_specialized_instruction_lti (struct jitter_parameter ** const ps,
7548 bool enable_fast_literals)
7549 {
7550 /* The prefix is a full specialized instruction. We're done recognizing it. */
7551 return pvm_specialized_instruction_opcode_lti;
7552 }
7553
7554 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ltiu(struct jitter_parameter ** const ps,bool enable_fast_literals)7555 pvm_recognize_specialized_instruction_ltiu (struct jitter_parameter ** const ps,
7556 bool enable_fast_literals)
7557 {
7558 /* The prefix is a full specialized instruction. We're done recognizing it. */
7559 return pvm_specialized_instruction_opcode_ltiu;
7560 }
7561
7562 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ltl(struct jitter_parameter ** const ps,bool enable_fast_literals)7563 pvm_recognize_specialized_instruction_ltl (struct jitter_parameter ** const ps,
7564 bool enable_fast_literals)
7565 {
7566 /* The prefix is a full specialized instruction. We're done recognizing it. */
7567 return pvm_specialized_instruction_opcode_ltl;
7568 }
7569
7570 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ltlu(struct jitter_parameter ** const ps,bool enable_fast_literals)7571 pvm_recognize_specialized_instruction_ltlu (struct jitter_parameter ** const ps,
7572 bool enable_fast_literals)
7573 {
7574 /* The prefix is a full specialized instruction. We're done recognizing it. */
7575 return pvm_specialized_instruction_opcode_ltlu;
7576 }
7577
7578 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ltoi(struct jitter_parameter ** const ps,bool enable_fast_literals)7579 pvm_recognize_specialized_instruction_ltoi (struct jitter_parameter ** const ps,
7580 bool enable_fast_literals)
7581 {
7582 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
7583 if (((* ps)->type == jitter_parameter_type_literal)
7584 && (res = pvm_recognize_specialized_instruction_ltoi__nR (ps + 1, enable_fast_literals)))
7585 goto done;
7586 done:
7587 return res;
7588 }
7589
7590 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ltoi__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)7591 pvm_recognize_specialized_instruction_ltoi__nR (struct jitter_parameter ** const ps,
7592 bool enable_fast_literals)
7593 {
7594 /* The prefix is a full specialized instruction. We're done recognizing it. */
7595 return pvm_specialized_instruction_opcode_ltoi__nR;
7596 }
7597
7598 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ltoiu(struct jitter_parameter ** const ps,bool enable_fast_literals)7599 pvm_recognize_specialized_instruction_ltoiu (struct jitter_parameter ** const ps,
7600 bool enable_fast_literals)
7601 {
7602 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
7603 if (((* ps)->type == jitter_parameter_type_literal)
7604 && (res = pvm_recognize_specialized_instruction_ltoiu__nR (ps + 1, enable_fast_literals)))
7605 goto done;
7606 done:
7607 return res;
7608 }
7609
7610 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ltoiu__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)7611 pvm_recognize_specialized_instruction_ltoiu__nR (struct jitter_parameter ** const ps,
7612 bool enable_fast_literals)
7613 {
7614 /* The prefix is a full specialized instruction. We're done recognizing it. */
7615 return pvm_specialized_instruction_opcode_ltoiu__nR;
7616 }
7617
7618 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ltol(struct jitter_parameter ** const ps,bool enable_fast_literals)7619 pvm_recognize_specialized_instruction_ltol (struct jitter_parameter ** const ps,
7620 bool enable_fast_literals)
7621 {
7622 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
7623 if (((* ps)->type == jitter_parameter_type_literal)
7624 && (res = pvm_recognize_specialized_instruction_ltol__nR (ps + 1, enable_fast_literals)))
7625 goto done;
7626 done:
7627 return res;
7628 }
7629
7630 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ltol__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)7631 pvm_recognize_specialized_instruction_ltol__nR (struct jitter_parameter ** const ps,
7632 bool enable_fast_literals)
7633 {
7634 /* The prefix is a full specialized instruction. We're done recognizing it. */
7635 return pvm_specialized_instruction_opcode_ltol__nR;
7636 }
7637
7638 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ltolu(struct jitter_parameter ** const ps,bool enable_fast_literals)7639 pvm_recognize_specialized_instruction_ltolu (struct jitter_parameter ** const ps,
7640 bool enable_fast_literals)
7641 {
7642 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
7643 if (((* ps)->type == jitter_parameter_type_literal)
7644 && (res = pvm_recognize_specialized_instruction_ltolu__nR (ps + 1, enable_fast_literals)))
7645 goto done;
7646 done:
7647 return res;
7648 }
7649
7650 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ltolu__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)7651 pvm_recognize_specialized_instruction_ltolu__nR (struct jitter_parameter ** const ps,
7652 bool enable_fast_literals)
7653 {
7654 /* The prefix is a full specialized instruction. We're done recognizing it. */
7655 return pvm_specialized_instruction_opcode_ltolu__nR;
7656 }
7657
7658 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_lts(struct jitter_parameter ** const ps,bool enable_fast_literals)7659 pvm_recognize_specialized_instruction_lts (struct jitter_parameter ** const ps,
7660 bool enable_fast_literals)
7661 {
7662 /* The prefix is a full specialized instruction. We're done recognizing it. */
7663 return pvm_specialized_instruction_opcode_lts;
7664 }
7665
7666 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_lutoi(struct jitter_parameter ** const ps,bool enable_fast_literals)7667 pvm_recognize_specialized_instruction_lutoi (struct jitter_parameter ** const ps,
7668 bool enable_fast_literals)
7669 {
7670 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
7671 if (((* ps)->type == jitter_parameter_type_literal)
7672 && (res = pvm_recognize_specialized_instruction_lutoi__nR (ps + 1, enable_fast_literals)))
7673 goto done;
7674 done:
7675 return res;
7676 }
7677
7678 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_lutoi__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)7679 pvm_recognize_specialized_instruction_lutoi__nR (struct jitter_parameter ** const ps,
7680 bool enable_fast_literals)
7681 {
7682 /* The prefix is a full specialized instruction. We're done recognizing it. */
7683 return pvm_specialized_instruction_opcode_lutoi__nR;
7684 }
7685
7686 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_lutoiu(struct jitter_parameter ** const ps,bool enable_fast_literals)7687 pvm_recognize_specialized_instruction_lutoiu (struct jitter_parameter ** const ps,
7688 bool enable_fast_literals)
7689 {
7690 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
7691 if (((* ps)->type == jitter_parameter_type_literal)
7692 && (res = pvm_recognize_specialized_instruction_lutoiu__nR (ps + 1, enable_fast_literals)))
7693 goto done;
7694 done:
7695 return res;
7696 }
7697
7698 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_lutoiu__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)7699 pvm_recognize_specialized_instruction_lutoiu__nR (struct jitter_parameter ** const ps,
7700 bool enable_fast_literals)
7701 {
7702 /* The prefix is a full specialized instruction. We're done recognizing it. */
7703 return pvm_specialized_instruction_opcode_lutoiu__nR;
7704 }
7705
7706 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_lutol(struct jitter_parameter ** const ps,bool enable_fast_literals)7707 pvm_recognize_specialized_instruction_lutol (struct jitter_parameter ** const ps,
7708 bool enable_fast_literals)
7709 {
7710 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
7711 if (((* ps)->type == jitter_parameter_type_literal)
7712 && (res = pvm_recognize_specialized_instruction_lutol__nR (ps + 1, enable_fast_literals)))
7713 goto done;
7714 done:
7715 return res;
7716 }
7717
7718 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_lutol__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)7719 pvm_recognize_specialized_instruction_lutol__nR (struct jitter_parameter ** const ps,
7720 bool enable_fast_literals)
7721 {
7722 /* The prefix is a full specialized instruction. We're done recognizing it. */
7723 return pvm_specialized_instruction_opcode_lutol__nR;
7724 }
7725
7726 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_lutolu(struct jitter_parameter ** const ps,bool enable_fast_literals)7727 pvm_recognize_specialized_instruction_lutolu (struct jitter_parameter ** const ps,
7728 bool enable_fast_literals)
7729 {
7730 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
7731 if (((* ps)->type == jitter_parameter_type_literal)
7732 && (res = pvm_recognize_specialized_instruction_lutolu__nR (ps + 1, enable_fast_literals)))
7733 goto done;
7734 done:
7735 return res;
7736 }
7737
7738 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_lutolu__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)7739 pvm_recognize_specialized_instruction_lutolu__nR (struct jitter_parameter ** const ps,
7740 bool enable_fast_literals)
7741 {
7742 /* The prefix is a full specialized instruction. We're done recognizing it. */
7743 return pvm_specialized_instruction_opcode_lutolu__nR;
7744 }
7745
7746 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_map(struct jitter_parameter ** const ps,bool enable_fast_literals)7747 pvm_recognize_specialized_instruction_map (struct jitter_parameter ** const ps,
7748 bool enable_fast_literals)
7749 {
7750 /* The prefix is a full specialized instruction. We're done recognizing it. */
7751 return pvm_specialized_instruction_opcode_map;
7752 }
7753
7754 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mgetios(struct jitter_parameter ** const ps,bool enable_fast_literals)7755 pvm_recognize_specialized_instruction_mgetios (struct jitter_parameter ** const ps,
7756 bool enable_fast_literals)
7757 {
7758 /* The prefix is a full specialized instruction. We're done recognizing it. */
7759 return pvm_specialized_instruction_opcode_mgetios;
7760 }
7761
7762 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mgetm(struct jitter_parameter ** const ps,bool enable_fast_literals)7763 pvm_recognize_specialized_instruction_mgetm (struct jitter_parameter ** const ps,
7764 bool enable_fast_literals)
7765 {
7766 /* The prefix is a full specialized instruction. We're done recognizing it. */
7767 return pvm_specialized_instruction_opcode_mgetm;
7768 }
7769
7770 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mgeto(struct jitter_parameter ** const ps,bool enable_fast_literals)7771 pvm_recognize_specialized_instruction_mgeto (struct jitter_parameter ** const ps,
7772 bool enable_fast_literals)
7773 {
7774 /* The prefix is a full specialized instruction. We're done recognizing it. */
7775 return pvm_specialized_instruction_opcode_mgeto;
7776 }
7777
7778 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mgets(struct jitter_parameter ** const ps,bool enable_fast_literals)7779 pvm_recognize_specialized_instruction_mgets (struct jitter_parameter ** const ps,
7780 bool enable_fast_literals)
7781 {
7782 /* The prefix is a full specialized instruction. We're done recognizing it. */
7783 return pvm_specialized_instruction_opcode_mgets;
7784 }
7785
7786 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mgetsel(struct jitter_parameter ** const ps,bool enable_fast_literals)7787 pvm_recognize_specialized_instruction_mgetsel (struct jitter_parameter ** const ps,
7788 bool enable_fast_literals)
7789 {
7790 /* The prefix is a full specialized instruction. We're done recognizing it. */
7791 return pvm_specialized_instruction_opcode_mgetsel;
7792 }
7793
7794 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mgetsiz(struct jitter_parameter ** const ps,bool enable_fast_literals)7795 pvm_recognize_specialized_instruction_mgetsiz (struct jitter_parameter ** const ps,
7796 bool enable_fast_literals)
7797 {
7798 /* The prefix is a full specialized instruction. We're done recognizing it. */
7799 return pvm_specialized_instruction_opcode_mgetsiz;
7800 }
7801
7802 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mgetw(struct jitter_parameter ** const ps,bool enable_fast_literals)7803 pvm_recognize_specialized_instruction_mgetw (struct jitter_parameter ** const ps,
7804 bool enable_fast_literals)
7805 {
7806 /* The prefix is a full specialized instruction. We're done recognizing it. */
7807 return pvm_specialized_instruction_opcode_mgetw;
7808 }
7809
7810 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mka(struct jitter_parameter ** const ps,bool enable_fast_literals)7811 pvm_recognize_specialized_instruction_mka (struct jitter_parameter ** const ps,
7812 bool enable_fast_literals)
7813 {
7814 /* The prefix is a full specialized instruction. We're done recognizing it. */
7815 return pvm_specialized_instruction_opcode_mka;
7816 }
7817
7818 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mko(struct jitter_parameter ** const ps,bool enable_fast_literals)7819 pvm_recognize_specialized_instruction_mko (struct jitter_parameter ** const ps,
7820 bool enable_fast_literals)
7821 {
7822 /* The prefix is a full specialized instruction. We're done recognizing it. */
7823 return pvm_specialized_instruction_opcode_mko;
7824 }
7825
7826 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mksct(struct jitter_parameter ** const ps,bool enable_fast_literals)7827 pvm_recognize_specialized_instruction_mksct (struct jitter_parameter ** const ps,
7828 bool enable_fast_literals)
7829 {
7830 /* The prefix is a full specialized instruction. We're done recognizing it. */
7831 return pvm_specialized_instruction_opcode_mksct;
7832 }
7833
7834 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mktya(struct jitter_parameter ** const ps,bool enable_fast_literals)7835 pvm_recognize_specialized_instruction_mktya (struct jitter_parameter ** const ps,
7836 bool enable_fast_literals)
7837 {
7838 /* The prefix is a full specialized instruction. We're done recognizing it. */
7839 return pvm_specialized_instruction_opcode_mktya;
7840 }
7841
7842 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mktyany(struct jitter_parameter ** const ps,bool enable_fast_literals)7843 pvm_recognize_specialized_instruction_mktyany (struct jitter_parameter ** const ps,
7844 bool enable_fast_literals)
7845 {
7846 /* The prefix is a full specialized instruction. We're done recognizing it. */
7847 return pvm_specialized_instruction_opcode_mktyany;
7848 }
7849
7850 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mktyc(struct jitter_parameter ** const ps,bool enable_fast_literals)7851 pvm_recognize_specialized_instruction_mktyc (struct jitter_parameter ** const ps,
7852 bool enable_fast_literals)
7853 {
7854 /* The prefix is a full specialized instruction. We're done recognizing it. */
7855 return pvm_specialized_instruction_opcode_mktyc;
7856 }
7857
7858 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mktyi(struct jitter_parameter ** const ps,bool enable_fast_literals)7859 pvm_recognize_specialized_instruction_mktyi (struct jitter_parameter ** const ps,
7860 bool enable_fast_literals)
7861 {
7862 /* The prefix is a full specialized instruction. We're done recognizing it. */
7863 return pvm_specialized_instruction_opcode_mktyi;
7864 }
7865
7866 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mktyo(struct jitter_parameter ** const ps,bool enable_fast_literals)7867 pvm_recognize_specialized_instruction_mktyo (struct jitter_parameter ** const ps,
7868 bool enable_fast_literals)
7869 {
7870 /* The prefix is a full specialized instruction. We're done recognizing it. */
7871 return pvm_specialized_instruction_opcode_mktyo;
7872 }
7873
7874 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mktys(struct jitter_parameter ** const ps,bool enable_fast_literals)7875 pvm_recognize_specialized_instruction_mktys (struct jitter_parameter ** const ps,
7876 bool enable_fast_literals)
7877 {
7878 /* The prefix is a full specialized instruction. We're done recognizing it. */
7879 return pvm_specialized_instruction_opcode_mktys;
7880 }
7881
7882 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mktysct(struct jitter_parameter ** const ps,bool enable_fast_literals)7883 pvm_recognize_specialized_instruction_mktysct (struct jitter_parameter ** const ps,
7884 bool enable_fast_literals)
7885 {
7886 /* The prefix is a full specialized instruction. We're done recognizing it. */
7887 return pvm_specialized_instruction_opcode_mktysct;
7888 }
7889
7890 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mktyv(struct jitter_parameter ** const ps,bool enable_fast_literals)7891 pvm_recognize_specialized_instruction_mktyv (struct jitter_parameter ** const ps,
7892 bool enable_fast_literals)
7893 {
7894 /* The prefix is a full specialized instruction. We're done recognizing it. */
7895 return pvm_specialized_instruction_opcode_mktyv;
7896 }
7897
7898 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mm(struct jitter_parameter ** const ps,bool enable_fast_literals)7899 pvm_recognize_specialized_instruction_mm (struct jitter_parameter ** const ps,
7900 bool enable_fast_literals)
7901 {
7902 /* The prefix is a full specialized instruction. We're done recognizing it. */
7903 return pvm_specialized_instruction_opcode_mm;
7904 }
7905
7906 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_modi(struct jitter_parameter ** const ps,bool enable_fast_literals)7907 pvm_recognize_specialized_instruction_modi (struct jitter_parameter ** const ps,
7908 bool enable_fast_literals)
7909 {
7910 /* The prefix is a full specialized instruction. We're done recognizing it. */
7911 return pvm_specialized_instruction_opcode_modi;
7912 }
7913
7914 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_modiu(struct jitter_parameter ** const ps,bool enable_fast_literals)7915 pvm_recognize_specialized_instruction_modiu (struct jitter_parameter ** const ps,
7916 bool enable_fast_literals)
7917 {
7918 /* The prefix is a full specialized instruction. We're done recognizing it. */
7919 return pvm_specialized_instruction_opcode_modiu;
7920 }
7921
7922 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_modl(struct jitter_parameter ** const ps,bool enable_fast_literals)7923 pvm_recognize_specialized_instruction_modl (struct jitter_parameter ** const ps,
7924 bool enable_fast_literals)
7925 {
7926 /* The prefix is a full specialized instruction. We're done recognizing it. */
7927 return pvm_specialized_instruction_opcode_modl;
7928 }
7929
7930 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_modlu(struct jitter_parameter ** const ps,bool enable_fast_literals)7931 pvm_recognize_specialized_instruction_modlu (struct jitter_parameter ** const ps,
7932 bool enable_fast_literals)
7933 {
7934 /* The prefix is a full specialized instruction. We're done recognizing it. */
7935 return pvm_specialized_instruction_opcode_modlu;
7936 }
7937
7938 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_msetios(struct jitter_parameter ** const ps,bool enable_fast_literals)7939 pvm_recognize_specialized_instruction_msetios (struct jitter_parameter ** const ps,
7940 bool enable_fast_literals)
7941 {
7942 /* The prefix is a full specialized instruction. We're done recognizing it. */
7943 return pvm_specialized_instruction_opcode_msetios;
7944 }
7945
7946 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_msetm(struct jitter_parameter ** const ps,bool enable_fast_literals)7947 pvm_recognize_specialized_instruction_msetm (struct jitter_parameter ** const ps,
7948 bool enable_fast_literals)
7949 {
7950 /* The prefix is a full specialized instruction. We're done recognizing it. */
7951 return pvm_specialized_instruction_opcode_msetm;
7952 }
7953
7954 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mseto(struct jitter_parameter ** const ps,bool enable_fast_literals)7955 pvm_recognize_specialized_instruction_mseto (struct jitter_parameter ** const ps,
7956 bool enable_fast_literals)
7957 {
7958 /* The prefix is a full specialized instruction. We're done recognizing it. */
7959 return pvm_specialized_instruction_opcode_mseto;
7960 }
7961
7962 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_msets(struct jitter_parameter ** const ps,bool enable_fast_literals)7963 pvm_recognize_specialized_instruction_msets (struct jitter_parameter ** const ps,
7964 bool enable_fast_literals)
7965 {
7966 /* The prefix is a full specialized instruction. We're done recognizing it. */
7967 return pvm_specialized_instruction_opcode_msets;
7968 }
7969
7970 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_msetsel(struct jitter_parameter ** const ps,bool enable_fast_literals)7971 pvm_recognize_specialized_instruction_msetsel (struct jitter_parameter ** const ps,
7972 bool enable_fast_literals)
7973 {
7974 /* The prefix is a full specialized instruction. We're done recognizing it. */
7975 return pvm_specialized_instruction_opcode_msetsel;
7976 }
7977
7978 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_msetsiz(struct jitter_parameter ** const ps,bool enable_fast_literals)7979 pvm_recognize_specialized_instruction_msetsiz (struct jitter_parameter ** const ps,
7980 bool enable_fast_literals)
7981 {
7982 /* The prefix is a full specialized instruction. We're done recognizing it. */
7983 return pvm_specialized_instruction_opcode_msetsiz;
7984 }
7985
7986 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_msetw(struct jitter_parameter ** const ps,bool enable_fast_literals)7987 pvm_recognize_specialized_instruction_msetw (struct jitter_parameter ** const ps,
7988 bool enable_fast_literals)
7989 {
7990 /* The prefix is a full specialized instruction. We're done recognizing it. */
7991 return pvm_specialized_instruction_opcode_msetw;
7992 }
7993
7994 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_muli(struct jitter_parameter ** const ps,bool enable_fast_literals)7995 pvm_recognize_specialized_instruction_muli (struct jitter_parameter ** const ps,
7996 bool enable_fast_literals)
7997 {
7998 /* The prefix is a full specialized instruction. We're done recognizing it. */
7999 return pvm_specialized_instruction_opcode_muli;
8000 }
8001
8002 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_muliu(struct jitter_parameter ** const ps,bool enable_fast_literals)8003 pvm_recognize_specialized_instruction_muliu (struct jitter_parameter ** const ps,
8004 bool enable_fast_literals)
8005 {
8006 /* The prefix is a full specialized instruction. We're done recognizing it. */
8007 return pvm_specialized_instruction_opcode_muliu;
8008 }
8009
8010 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mull(struct jitter_parameter ** const ps,bool enable_fast_literals)8011 pvm_recognize_specialized_instruction_mull (struct jitter_parameter ** const ps,
8012 bool enable_fast_literals)
8013 {
8014 /* The prefix is a full specialized instruction. We're done recognizing it. */
8015 return pvm_specialized_instruction_opcode_mull;
8016 }
8017
8018 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_mullu(struct jitter_parameter ** const ps,bool enable_fast_literals)8019 pvm_recognize_specialized_instruction_mullu (struct jitter_parameter ** const ps,
8020 bool enable_fast_literals)
8021 {
8022 /* The prefix is a full specialized instruction. We're done recognizing it. */
8023 return pvm_specialized_instruction_opcode_mullu;
8024 }
8025
8026 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_muls(struct jitter_parameter ** const ps,bool enable_fast_literals)8027 pvm_recognize_specialized_instruction_muls (struct jitter_parameter ** const ps,
8028 bool enable_fast_literals)
8029 {
8030 /* The prefix is a full specialized instruction. We're done recognizing it. */
8031 return pvm_specialized_instruction_opcode_muls;
8032 }
8033
8034 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_negi(struct jitter_parameter ** const ps,bool enable_fast_literals)8035 pvm_recognize_specialized_instruction_negi (struct jitter_parameter ** const ps,
8036 bool enable_fast_literals)
8037 {
8038 /* The prefix is a full specialized instruction. We're done recognizing it. */
8039 return pvm_specialized_instruction_opcode_negi;
8040 }
8041
8042 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_negiu(struct jitter_parameter ** const ps,bool enable_fast_literals)8043 pvm_recognize_specialized_instruction_negiu (struct jitter_parameter ** const ps,
8044 bool enable_fast_literals)
8045 {
8046 /* The prefix is a full specialized instruction. We're done recognizing it. */
8047 return pvm_specialized_instruction_opcode_negiu;
8048 }
8049
8050 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_negl(struct jitter_parameter ** const ps,bool enable_fast_literals)8051 pvm_recognize_specialized_instruction_negl (struct jitter_parameter ** const ps,
8052 bool enable_fast_literals)
8053 {
8054 /* The prefix is a full specialized instruction. We're done recognizing it. */
8055 return pvm_specialized_instruction_opcode_negl;
8056 }
8057
8058 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_neglu(struct jitter_parameter ** const ps,bool enable_fast_literals)8059 pvm_recognize_specialized_instruction_neglu (struct jitter_parameter ** const ps,
8060 bool enable_fast_literals)
8061 {
8062 /* The prefix is a full specialized instruction. We're done recognizing it. */
8063 return pvm_specialized_instruction_opcode_neglu;
8064 }
8065
8066 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_nei(struct jitter_parameter ** const ps,bool enable_fast_literals)8067 pvm_recognize_specialized_instruction_nei (struct jitter_parameter ** const ps,
8068 bool enable_fast_literals)
8069 {
8070 /* The prefix is a full specialized instruction. We're done recognizing it. */
8071 return pvm_specialized_instruction_opcode_nei;
8072 }
8073
8074 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_neiu(struct jitter_parameter ** const ps,bool enable_fast_literals)8075 pvm_recognize_specialized_instruction_neiu (struct jitter_parameter ** const ps,
8076 bool enable_fast_literals)
8077 {
8078 /* The prefix is a full specialized instruction. We're done recognizing it. */
8079 return pvm_specialized_instruction_opcode_neiu;
8080 }
8081
8082 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_nel(struct jitter_parameter ** const ps,bool enable_fast_literals)8083 pvm_recognize_specialized_instruction_nel (struct jitter_parameter ** const ps,
8084 bool enable_fast_literals)
8085 {
8086 /* The prefix is a full specialized instruction. We're done recognizing it. */
8087 return pvm_specialized_instruction_opcode_nel;
8088 }
8089
8090 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_nelu(struct jitter_parameter ** const ps,bool enable_fast_literals)8091 pvm_recognize_specialized_instruction_nelu (struct jitter_parameter ** const ps,
8092 bool enable_fast_literals)
8093 {
8094 /* The prefix is a full specialized instruction. We're done recognizing it. */
8095 return pvm_specialized_instruction_opcode_nelu;
8096 }
8097
8098 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_nes(struct jitter_parameter ** const ps,bool enable_fast_literals)8099 pvm_recognize_specialized_instruction_nes (struct jitter_parameter ** const ps,
8100 bool enable_fast_literals)
8101 {
8102 /* The prefix is a full specialized instruction. We're done recognizing it. */
8103 return pvm_specialized_instruction_opcode_nes;
8104 }
8105
8106 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_nip(struct jitter_parameter ** const ps,bool enable_fast_literals)8107 pvm_recognize_specialized_instruction_nip (struct jitter_parameter ** const ps,
8108 bool enable_fast_literals)
8109 {
8110 /* The prefix is a full specialized instruction. We're done recognizing it. */
8111 return pvm_specialized_instruction_opcode_nip;
8112 }
8113
8114 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_nip2(struct jitter_parameter ** const ps,bool enable_fast_literals)8115 pvm_recognize_specialized_instruction_nip2 (struct jitter_parameter ** const ps,
8116 bool enable_fast_literals)
8117 {
8118 /* The prefix is a full specialized instruction. We're done recognizing it. */
8119 return pvm_specialized_instruction_opcode_nip2;
8120 }
8121
8122 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_nip3(struct jitter_parameter ** const ps,bool enable_fast_literals)8123 pvm_recognize_specialized_instruction_nip3 (struct jitter_parameter ** const ps,
8124 bool enable_fast_literals)
8125 {
8126 /* The prefix is a full specialized instruction. We're done recognizing it. */
8127 return pvm_specialized_instruction_opcode_nip3;
8128 }
8129
8130 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_nn(struct jitter_parameter ** const ps,bool enable_fast_literals)8131 pvm_recognize_specialized_instruction_nn (struct jitter_parameter ** const ps,
8132 bool enable_fast_literals)
8133 {
8134 /* The prefix is a full specialized instruction. We're done recognizing it. */
8135 return pvm_specialized_instruction_opcode_nn;
8136 }
8137
8138 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_nnn(struct jitter_parameter ** const ps,bool enable_fast_literals)8139 pvm_recognize_specialized_instruction_nnn (struct jitter_parameter ** const ps,
8140 bool enable_fast_literals)
8141 {
8142 /* The prefix is a full specialized instruction. We're done recognizing it. */
8143 return pvm_specialized_instruction_opcode_nnn;
8144 }
8145
8146 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_nop(struct jitter_parameter ** const ps,bool enable_fast_literals)8147 pvm_recognize_specialized_instruction_nop (struct jitter_parameter ** const ps,
8148 bool enable_fast_literals)
8149 {
8150 /* The prefix is a full specialized instruction. We're done recognizing it. */
8151 return pvm_specialized_instruction_opcode_nop;
8152 }
8153
8154 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_not(struct jitter_parameter ** const ps,bool enable_fast_literals)8155 pvm_recognize_specialized_instruction_not (struct jitter_parameter ** const ps,
8156 bool enable_fast_literals)
8157 {
8158 /* The prefix is a full specialized instruction. We're done recognizing it. */
8159 return pvm_specialized_instruction_opcode_not;
8160 }
8161
8162 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_note(struct jitter_parameter ** const ps,bool enable_fast_literals)8163 pvm_recognize_specialized_instruction_note (struct jitter_parameter ** const ps,
8164 bool enable_fast_literals)
8165 {
8166 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8167 if (((* ps)->type == jitter_parameter_type_literal)
8168 && (res = pvm_recognize_specialized_instruction_note__nR (ps + 1, enable_fast_literals)))
8169 goto done;
8170 done:
8171 return res;
8172 }
8173
8174 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_note__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8175 pvm_recognize_specialized_instruction_note__nR (struct jitter_parameter ** const ps,
8176 bool enable_fast_literals)
8177 {
8178 /* The prefix is a full specialized instruction. We're done recognizing it. */
8179 return pvm_specialized_instruction_opcode_note__nR;
8180 }
8181
8182 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_nrot(struct jitter_parameter ** const ps,bool enable_fast_literals)8183 pvm_recognize_specialized_instruction_nrot (struct jitter_parameter ** const ps,
8184 bool enable_fast_literals)
8185 {
8186 /* The prefix is a full specialized instruction. We're done recognizing it. */
8187 return pvm_specialized_instruction_opcode_nrot;
8188 }
8189
8190 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ogetbt(struct jitter_parameter ** const ps,bool enable_fast_literals)8191 pvm_recognize_specialized_instruction_ogetbt (struct jitter_parameter ** const ps,
8192 bool enable_fast_literals)
8193 {
8194 /* The prefix is a full specialized instruction. We're done recognizing it. */
8195 return pvm_specialized_instruction_opcode_ogetbt;
8196 }
8197
8198 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ogetm(struct jitter_parameter ** const ps,bool enable_fast_literals)8199 pvm_recognize_specialized_instruction_ogetm (struct jitter_parameter ** const ps,
8200 bool enable_fast_literals)
8201 {
8202 /* The prefix is a full specialized instruction. We're done recognizing it. */
8203 return pvm_specialized_instruction_opcode_ogetm;
8204 }
8205
8206 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ogetu(struct jitter_parameter ** const ps,bool enable_fast_literals)8207 pvm_recognize_specialized_instruction_ogetu (struct jitter_parameter ** const ps,
8208 bool enable_fast_literals)
8209 {
8210 /* The prefix is a full specialized instruction. We're done recognizing it. */
8211 return pvm_specialized_instruction_opcode_ogetu;
8212 }
8213
8214 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_open(struct jitter_parameter ** const ps,bool enable_fast_literals)8215 pvm_recognize_specialized_instruction_open (struct jitter_parameter ** const ps,
8216 bool enable_fast_literals)
8217 {
8218 /* The prefix is a full specialized instruction. We're done recognizing it. */
8219 return pvm_specialized_instruction_opcode_open;
8220 }
8221
8222 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_or(struct jitter_parameter ** const ps,bool enable_fast_literals)8223 pvm_recognize_specialized_instruction_or (struct jitter_parameter ** const ps,
8224 bool enable_fast_literals)
8225 {
8226 /* The prefix is a full specialized instruction. We're done recognizing it. */
8227 return pvm_specialized_instruction_opcode_or;
8228 }
8229
8230 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_osetm(struct jitter_parameter ** const ps,bool enable_fast_literals)8231 pvm_recognize_specialized_instruction_osetm (struct jitter_parameter ** const ps,
8232 bool enable_fast_literals)
8233 {
8234 /* The prefix is a full specialized instruction. We're done recognizing it. */
8235 return pvm_specialized_instruction_opcode_osetm;
8236 }
8237
8238 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_over(struct jitter_parameter ** const ps,bool enable_fast_literals)8239 pvm_recognize_specialized_instruction_over (struct jitter_parameter ** const ps,
8240 bool enable_fast_literals)
8241 {
8242 /* The prefix is a full specialized instruction. We're done recognizing it. */
8243 return pvm_specialized_instruction_opcode_over;
8244 }
8245
8246 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pec(struct jitter_parameter ** const ps,bool enable_fast_literals)8247 pvm_recognize_specialized_instruction_pec (struct jitter_parameter ** const ps,
8248 bool enable_fast_literals)
8249 {
8250 /* The prefix is a full specialized instruction. We're done recognizing it. */
8251 return pvm_specialized_instruction_opcode_pec;
8252 }
8253
8254 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peekdi(struct jitter_parameter ** const ps,bool enable_fast_literals)8255 pvm_recognize_specialized_instruction_peekdi (struct jitter_parameter ** const ps,
8256 bool enable_fast_literals)
8257 {
8258 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8259 if (((* ps)->type == jitter_parameter_type_literal)
8260 && (res = pvm_recognize_specialized_instruction_peekdi__nR (ps + 1, enable_fast_literals)))
8261 goto done;
8262 done:
8263 return res;
8264 }
8265
8266 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peekdi__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8267 pvm_recognize_specialized_instruction_peekdi__nR (struct jitter_parameter ** const ps,
8268 bool enable_fast_literals)
8269 {
8270 /* The prefix is a full specialized instruction. We're done recognizing it. */
8271 return pvm_specialized_instruction_opcode_peekdi__nR;
8272 }
8273
8274 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peekdiu(struct jitter_parameter ** const ps,bool enable_fast_literals)8275 pvm_recognize_specialized_instruction_peekdiu (struct jitter_parameter ** const ps,
8276 bool enable_fast_literals)
8277 {
8278 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8279 if (((* ps)->type == jitter_parameter_type_literal)
8280 && (res = pvm_recognize_specialized_instruction_peekdiu__nR (ps + 1, enable_fast_literals)))
8281 goto done;
8282 done:
8283 return res;
8284 }
8285
8286 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peekdiu__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8287 pvm_recognize_specialized_instruction_peekdiu__nR (struct jitter_parameter ** const ps,
8288 bool enable_fast_literals)
8289 {
8290 /* The prefix is a full specialized instruction. We're done recognizing it. */
8291 return pvm_specialized_instruction_opcode_peekdiu__nR;
8292 }
8293
8294 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peekdl(struct jitter_parameter ** const ps,bool enable_fast_literals)8295 pvm_recognize_specialized_instruction_peekdl (struct jitter_parameter ** const ps,
8296 bool enable_fast_literals)
8297 {
8298 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8299 if (((* ps)->type == jitter_parameter_type_literal)
8300 && (res = pvm_recognize_specialized_instruction_peekdl__nR (ps + 1, enable_fast_literals)))
8301 goto done;
8302 done:
8303 return res;
8304 }
8305
8306 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peekdl__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8307 pvm_recognize_specialized_instruction_peekdl__nR (struct jitter_parameter ** const ps,
8308 bool enable_fast_literals)
8309 {
8310 /* The prefix is a full specialized instruction. We're done recognizing it. */
8311 return pvm_specialized_instruction_opcode_peekdl__nR;
8312 }
8313
8314 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peekdlu(struct jitter_parameter ** const ps,bool enable_fast_literals)8315 pvm_recognize_specialized_instruction_peekdlu (struct jitter_parameter ** const ps,
8316 bool enable_fast_literals)
8317 {
8318 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8319 if (((* ps)->type == jitter_parameter_type_literal)
8320 && (res = pvm_recognize_specialized_instruction_peekdlu__nR (ps + 1, enable_fast_literals)))
8321 goto done;
8322 done:
8323 return res;
8324 }
8325
8326 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peekdlu__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8327 pvm_recognize_specialized_instruction_peekdlu__nR (struct jitter_parameter ** const ps,
8328 bool enable_fast_literals)
8329 {
8330 /* The prefix is a full specialized instruction. We're done recognizing it. */
8331 return pvm_specialized_instruction_opcode_peekdlu__nR;
8332 }
8333
8334 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peeki(struct jitter_parameter ** const ps,bool enable_fast_literals)8335 pvm_recognize_specialized_instruction_peeki (struct jitter_parameter ** const ps,
8336 bool enable_fast_literals)
8337 {
8338 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8339 if (((* ps)->type == jitter_parameter_type_literal)
8340 && (res = pvm_recognize_specialized_instruction_peeki__nR (ps + 1, enable_fast_literals)))
8341 goto done;
8342 done:
8343 return res;
8344 }
8345
8346 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peeki__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8347 pvm_recognize_specialized_instruction_peeki__nR (struct jitter_parameter ** const ps,
8348 bool enable_fast_literals)
8349 {
8350 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8351 if (((* ps)->type == jitter_parameter_type_literal)
8352 && (res = pvm_recognize_specialized_instruction_peeki__nR__nR (ps + 1, enable_fast_literals)))
8353 goto done;
8354 done:
8355 return res;
8356 }
8357
8358 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peeki__nR__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8359 pvm_recognize_specialized_instruction_peeki__nR__nR (struct jitter_parameter ** const ps,
8360 bool enable_fast_literals)
8361 {
8362 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8363 if (((* ps)->type == jitter_parameter_type_literal)
8364 && (res = pvm_recognize_specialized_instruction_peeki__nR__nR__nR (ps + 1, enable_fast_literals)))
8365 goto done;
8366 done:
8367 return res;
8368 }
8369
8370 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peeki__nR__nR__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8371 pvm_recognize_specialized_instruction_peeki__nR__nR__nR (struct jitter_parameter ** const ps,
8372 bool enable_fast_literals)
8373 {
8374 /* The prefix is a full specialized instruction. We're done recognizing it. */
8375 return pvm_specialized_instruction_opcode_peeki__nR__nR__nR;
8376 }
8377
8378 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peekiu(struct jitter_parameter ** const ps,bool enable_fast_literals)8379 pvm_recognize_specialized_instruction_peekiu (struct jitter_parameter ** const ps,
8380 bool enable_fast_literals)
8381 {
8382 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8383 if (((* ps)->type == jitter_parameter_type_literal)
8384 && (res = pvm_recognize_specialized_instruction_peekiu__nR (ps + 1, enable_fast_literals)))
8385 goto done;
8386 done:
8387 return res;
8388 }
8389
8390 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peekiu__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8391 pvm_recognize_specialized_instruction_peekiu__nR (struct jitter_parameter ** const ps,
8392 bool enable_fast_literals)
8393 {
8394 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8395 if (((* ps)->type == jitter_parameter_type_literal)
8396 && (res = pvm_recognize_specialized_instruction_peekiu__nR__nR (ps + 1, enable_fast_literals)))
8397 goto done;
8398 done:
8399 return res;
8400 }
8401
8402 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peekiu__nR__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8403 pvm_recognize_specialized_instruction_peekiu__nR__nR (struct jitter_parameter ** const ps,
8404 bool enable_fast_literals)
8405 {
8406 /* The prefix is a full specialized instruction. We're done recognizing it. */
8407 return pvm_specialized_instruction_opcode_peekiu__nR__nR;
8408 }
8409
8410 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peekl(struct jitter_parameter ** const ps,bool enable_fast_literals)8411 pvm_recognize_specialized_instruction_peekl (struct jitter_parameter ** const ps,
8412 bool enable_fast_literals)
8413 {
8414 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8415 if (((* ps)->type == jitter_parameter_type_literal)
8416 && (res = pvm_recognize_specialized_instruction_peekl__nR (ps + 1, enable_fast_literals)))
8417 goto done;
8418 done:
8419 return res;
8420 }
8421
8422 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peekl__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8423 pvm_recognize_specialized_instruction_peekl__nR (struct jitter_parameter ** const ps,
8424 bool enable_fast_literals)
8425 {
8426 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8427 if (((* ps)->type == jitter_parameter_type_literal)
8428 && (res = pvm_recognize_specialized_instruction_peekl__nR__nR (ps + 1, enable_fast_literals)))
8429 goto done;
8430 done:
8431 return res;
8432 }
8433
8434 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peekl__nR__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8435 pvm_recognize_specialized_instruction_peekl__nR__nR (struct jitter_parameter ** const ps,
8436 bool enable_fast_literals)
8437 {
8438 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8439 if (((* ps)->type == jitter_parameter_type_literal)
8440 && (res = pvm_recognize_specialized_instruction_peekl__nR__nR__nR (ps + 1, enable_fast_literals)))
8441 goto done;
8442 done:
8443 return res;
8444 }
8445
8446 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peekl__nR__nR__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8447 pvm_recognize_specialized_instruction_peekl__nR__nR__nR (struct jitter_parameter ** const ps,
8448 bool enable_fast_literals)
8449 {
8450 /* The prefix is a full specialized instruction. We're done recognizing it. */
8451 return pvm_specialized_instruction_opcode_peekl__nR__nR__nR;
8452 }
8453
8454 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peeklu(struct jitter_parameter ** const ps,bool enable_fast_literals)8455 pvm_recognize_specialized_instruction_peeklu (struct jitter_parameter ** const ps,
8456 bool enable_fast_literals)
8457 {
8458 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8459 if (((* ps)->type == jitter_parameter_type_literal)
8460 && (res = pvm_recognize_specialized_instruction_peeklu__nR (ps + 1, enable_fast_literals)))
8461 goto done;
8462 done:
8463 return res;
8464 }
8465
8466 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peeklu__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8467 pvm_recognize_specialized_instruction_peeklu__nR (struct jitter_parameter ** const ps,
8468 bool enable_fast_literals)
8469 {
8470 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8471 if (((* ps)->type == jitter_parameter_type_literal)
8472 && (res = pvm_recognize_specialized_instruction_peeklu__nR__nR (ps + 1, enable_fast_literals)))
8473 goto done;
8474 done:
8475 return res;
8476 }
8477
8478 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peeklu__nR__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8479 pvm_recognize_specialized_instruction_peeklu__nR__nR (struct jitter_parameter ** const ps,
8480 bool enable_fast_literals)
8481 {
8482 /* The prefix is a full specialized instruction. We're done recognizing it. */
8483 return pvm_specialized_instruction_opcode_peeklu__nR__nR;
8484 }
8485
8486 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_peeks(struct jitter_parameter ** const ps,bool enable_fast_literals)8487 pvm_recognize_specialized_instruction_peeks (struct jitter_parameter ** const ps,
8488 bool enable_fast_literals)
8489 {
8490 /* The prefix is a full specialized instruction. We're done recognizing it. */
8491 return pvm_specialized_instruction_opcode_peeks;
8492 }
8493
8494 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokedi(struct jitter_parameter ** const ps,bool enable_fast_literals)8495 pvm_recognize_specialized_instruction_pokedi (struct jitter_parameter ** const ps,
8496 bool enable_fast_literals)
8497 {
8498 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8499 if (((* ps)->type == jitter_parameter_type_literal)
8500 && (res = pvm_recognize_specialized_instruction_pokedi__nR (ps + 1, enable_fast_literals)))
8501 goto done;
8502 done:
8503 return res;
8504 }
8505
8506 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokedi__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8507 pvm_recognize_specialized_instruction_pokedi__nR (struct jitter_parameter ** const ps,
8508 bool enable_fast_literals)
8509 {
8510 /* The prefix is a full specialized instruction. We're done recognizing it. */
8511 return pvm_specialized_instruction_opcode_pokedi__nR;
8512 }
8513
8514 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokediu(struct jitter_parameter ** const ps,bool enable_fast_literals)8515 pvm_recognize_specialized_instruction_pokediu (struct jitter_parameter ** const ps,
8516 bool enable_fast_literals)
8517 {
8518 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8519 if (((* ps)->type == jitter_parameter_type_literal)
8520 && (res = pvm_recognize_specialized_instruction_pokediu__nR (ps + 1, enable_fast_literals)))
8521 goto done;
8522 done:
8523 return res;
8524 }
8525
8526 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokediu__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8527 pvm_recognize_specialized_instruction_pokediu__nR (struct jitter_parameter ** const ps,
8528 bool enable_fast_literals)
8529 {
8530 /* The prefix is a full specialized instruction. We're done recognizing it. */
8531 return pvm_specialized_instruction_opcode_pokediu__nR;
8532 }
8533
8534 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokedl(struct jitter_parameter ** const ps,bool enable_fast_literals)8535 pvm_recognize_specialized_instruction_pokedl (struct jitter_parameter ** const ps,
8536 bool enable_fast_literals)
8537 {
8538 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8539 if (((* ps)->type == jitter_parameter_type_literal)
8540 && (res = pvm_recognize_specialized_instruction_pokedl__nR (ps + 1, enable_fast_literals)))
8541 goto done;
8542 done:
8543 return res;
8544 }
8545
8546 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokedl__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8547 pvm_recognize_specialized_instruction_pokedl__nR (struct jitter_parameter ** const ps,
8548 bool enable_fast_literals)
8549 {
8550 /* The prefix is a full specialized instruction. We're done recognizing it. */
8551 return pvm_specialized_instruction_opcode_pokedl__nR;
8552 }
8553
8554 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokedlu(struct jitter_parameter ** const ps,bool enable_fast_literals)8555 pvm_recognize_specialized_instruction_pokedlu (struct jitter_parameter ** const ps,
8556 bool enable_fast_literals)
8557 {
8558 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8559 if (((* ps)->type == jitter_parameter_type_literal)
8560 && (res = pvm_recognize_specialized_instruction_pokedlu__nR (ps + 1, enable_fast_literals)))
8561 goto done;
8562 done:
8563 return res;
8564 }
8565
8566 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokedlu__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8567 pvm_recognize_specialized_instruction_pokedlu__nR (struct jitter_parameter ** const ps,
8568 bool enable_fast_literals)
8569 {
8570 /* The prefix is a full specialized instruction. We're done recognizing it. */
8571 return pvm_specialized_instruction_opcode_pokedlu__nR;
8572 }
8573
8574 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokei(struct jitter_parameter ** const ps,bool enable_fast_literals)8575 pvm_recognize_specialized_instruction_pokei (struct jitter_parameter ** const ps,
8576 bool enable_fast_literals)
8577 {
8578 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8579 if (((* ps)->type == jitter_parameter_type_literal)
8580 && (res = pvm_recognize_specialized_instruction_pokei__nR (ps + 1, enable_fast_literals)))
8581 goto done;
8582 done:
8583 return res;
8584 }
8585
8586 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokei__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8587 pvm_recognize_specialized_instruction_pokei__nR (struct jitter_parameter ** const ps,
8588 bool enable_fast_literals)
8589 {
8590 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8591 if (((* ps)->type == jitter_parameter_type_literal)
8592 && (res = pvm_recognize_specialized_instruction_pokei__nR__nR (ps + 1, enable_fast_literals)))
8593 goto done;
8594 done:
8595 return res;
8596 }
8597
8598 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokei__nR__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8599 pvm_recognize_specialized_instruction_pokei__nR__nR (struct jitter_parameter ** const ps,
8600 bool enable_fast_literals)
8601 {
8602 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8603 if (((* ps)->type == jitter_parameter_type_literal)
8604 && (res = pvm_recognize_specialized_instruction_pokei__nR__nR__nR (ps + 1, enable_fast_literals)))
8605 goto done;
8606 done:
8607 return res;
8608 }
8609
8610 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokei__nR__nR__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8611 pvm_recognize_specialized_instruction_pokei__nR__nR__nR (struct jitter_parameter ** const ps,
8612 bool enable_fast_literals)
8613 {
8614 /* The prefix is a full specialized instruction. We're done recognizing it. */
8615 return pvm_specialized_instruction_opcode_pokei__nR__nR__nR;
8616 }
8617
8618 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokeiu(struct jitter_parameter ** const ps,bool enable_fast_literals)8619 pvm_recognize_specialized_instruction_pokeiu (struct jitter_parameter ** const ps,
8620 bool enable_fast_literals)
8621 {
8622 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8623 if (((* ps)->type == jitter_parameter_type_literal)
8624 && (res = pvm_recognize_specialized_instruction_pokeiu__nR (ps + 1, enable_fast_literals)))
8625 goto done;
8626 done:
8627 return res;
8628 }
8629
8630 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokeiu__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8631 pvm_recognize_specialized_instruction_pokeiu__nR (struct jitter_parameter ** const ps,
8632 bool enable_fast_literals)
8633 {
8634 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8635 if (((* ps)->type == jitter_parameter_type_literal)
8636 && (res = pvm_recognize_specialized_instruction_pokeiu__nR__nR (ps + 1, enable_fast_literals)))
8637 goto done;
8638 done:
8639 return res;
8640 }
8641
8642 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokeiu__nR__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8643 pvm_recognize_specialized_instruction_pokeiu__nR__nR (struct jitter_parameter ** const ps,
8644 bool enable_fast_literals)
8645 {
8646 /* The prefix is a full specialized instruction. We're done recognizing it. */
8647 return pvm_specialized_instruction_opcode_pokeiu__nR__nR;
8648 }
8649
8650 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokel(struct jitter_parameter ** const ps,bool enable_fast_literals)8651 pvm_recognize_specialized_instruction_pokel (struct jitter_parameter ** const ps,
8652 bool enable_fast_literals)
8653 {
8654 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8655 if (((* ps)->type == jitter_parameter_type_literal)
8656 && (res = pvm_recognize_specialized_instruction_pokel__nR (ps + 1, enable_fast_literals)))
8657 goto done;
8658 done:
8659 return res;
8660 }
8661
8662 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokel__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8663 pvm_recognize_specialized_instruction_pokel__nR (struct jitter_parameter ** const ps,
8664 bool enable_fast_literals)
8665 {
8666 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8667 if (((* ps)->type == jitter_parameter_type_literal)
8668 && (res = pvm_recognize_specialized_instruction_pokel__nR__nR (ps + 1, enable_fast_literals)))
8669 goto done;
8670 done:
8671 return res;
8672 }
8673
8674 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokel__nR__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8675 pvm_recognize_specialized_instruction_pokel__nR__nR (struct jitter_parameter ** const ps,
8676 bool enable_fast_literals)
8677 {
8678 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8679 if (((* ps)->type == jitter_parameter_type_literal)
8680 && (res = pvm_recognize_specialized_instruction_pokel__nR__nR__nR (ps + 1, enable_fast_literals)))
8681 goto done;
8682 done:
8683 return res;
8684 }
8685
8686 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokel__nR__nR__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8687 pvm_recognize_specialized_instruction_pokel__nR__nR__nR (struct jitter_parameter ** const ps,
8688 bool enable_fast_literals)
8689 {
8690 /* The prefix is a full specialized instruction. We're done recognizing it. */
8691 return pvm_specialized_instruction_opcode_pokel__nR__nR__nR;
8692 }
8693
8694 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokelu(struct jitter_parameter ** const ps,bool enable_fast_literals)8695 pvm_recognize_specialized_instruction_pokelu (struct jitter_parameter ** const ps,
8696 bool enable_fast_literals)
8697 {
8698 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8699 if (((* ps)->type == jitter_parameter_type_literal)
8700 && (res = pvm_recognize_specialized_instruction_pokelu__nR (ps + 1, enable_fast_literals)))
8701 goto done;
8702 done:
8703 return res;
8704 }
8705
8706 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokelu__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8707 pvm_recognize_specialized_instruction_pokelu__nR (struct jitter_parameter ** const ps,
8708 bool enable_fast_literals)
8709 {
8710 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8711 if (((* ps)->type == jitter_parameter_type_literal)
8712 && (res = pvm_recognize_specialized_instruction_pokelu__nR__nR (ps + 1, enable_fast_literals)))
8713 goto done;
8714 done:
8715 return res;
8716 }
8717
8718 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokelu__nR__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8719 pvm_recognize_specialized_instruction_pokelu__nR__nR (struct jitter_parameter ** const ps,
8720 bool enable_fast_literals)
8721 {
8722 /* The prefix is a full specialized instruction. We're done recognizing it. */
8723 return pvm_specialized_instruction_opcode_pokelu__nR__nR;
8724 }
8725
8726 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pokes(struct jitter_parameter ** const ps,bool enable_fast_literals)8727 pvm_recognize_specialized_instruction_pokes (struct jitter_parameter ** const ps,
8728 bool enable_fast_literals)
8729 {
8730 /* The prefix is a full specialized instruction. We're done recognizing it. */
8731 return pvm_specialized_instruction_opcode_pokes;
8732 }
8733
8734 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pope(struct jitter_parameter ** const ps,bool enable_fast_literals)8735 pvm_recognize_specialized_instruction_pope (struct jitter_parameter ** const ps,
8736 bool enable_fast_literals)
8737 {
8738 /* The prefix is a full specialized instruction. We're done recognizing it. */
8739 return pvm_specialized_instruction_opcode_pope;
8740 }
8741
8742 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_popend(struct jitter_parameter ** const ps,bool enable_fast_literals)8743 pvm_recognize_specialized_instruction_popend (struct jitter_parameter ** const ps,
8744 bool enable_fast_literals)
8745 {
8746 /* The prefix is a full specialized instruction. We're done recognizing it. */
8747 return pvm_specialized_instruction_opcode_popend;
8748 }
8749
8750 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_popf(struct jitter_parameter ** const ps,bool enable_fast_literals)8751 pvm_recognize_specialized_instruction_popf (struct jitter_parameter ** const ps,
8752 bool enable_fast_literals)
8753 {
8754 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8755 if (((* ps)->type == jitter_parameter_type_literal)
8756 && (res = pvm_recognize_specialized_instruction_popf__nR (ps + 1, enable_fast_literals)))
8757 goto done;
8758 done:
8759 return res;
8760 }
8761
8762 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_popf__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8763 pvm_recognize_specialized_instruction_popf__nR (struct jitter_parameter ** const ps,
8764 bool enable_fast_literals)
8765 {
8766 /* The prefix is a full specialized instruction. We're done recognizing it. */
8767 return pvm_specialized_instruction_opcode_popf__nR;
8768 }
8769
8770 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_popios(struct jitter_parameter ** const ps,bool enable_fast_literals)8771 pvm_recognize_specialized_instruction_popios (struct jitter_parameter ** const ps,
8772 bool enable_fast_literals)
8773 {
8774 /* The prefix is a full specialized instruction. We're done recognizing it. */
8775 return pvm_specialized_instruction_opcode_popios;
8776 }
8777
8778 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_popoac(struct jitter_parameter ** const ps,bool enable_fast_literals)8779 pvm_recognize_specialized_instruction_popoac (struct jitter_parameter ** const ps,
8780 bool enable_fast_literals)
8781 {
8782 /* The prefix is a full specialized instruction. We're done recognizing it. */
8783 return pvm_specialized_instruction_opcode_popoac;
8784 }
8785
8786 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_popob(struct jitter_parameter ** const ps,bool enable_fast_literals)8787 pvm_recognize_specialized_instruction_popob (struct jitter_parameter ** const ps,
8788 bool enable_fast_literals)
8789 {
8790 /* The prefix is a full specialized instruction. We're done recognizing it. */
8791 return pvm_specialized_instruction_opcode_popob;
8792 }
8793
8794 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_popobc(struct jitter_parameter ** const ps,bool enable_fast_literals)8795 pvm_recognize_specialized_instruction_popobc (struct jitter_parameter ** const ps,
8796 bool enable_fast_literals)
8797 {
8798 /* The prefix is a full specialized instruction. We're done recognizing it. */
8799 return pvm_specialized_instruction_opcode_popobc;
8800 }
8801
8802 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_popoc(struct jitter_parameter ** const ps,bool enable_fast_literals)8803 pvm_recognize_specialized_instruction_popoc (struct jitter_parameter ** const ps,
8804 bool enable_fast_literals)
8805 {
8806 /* The prefix is a full specialized instruction. We're done recognizing it. */
8807 return pvm_specialized_instruction_opcode_popoc;
8808 }
8809
8810 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_popod(struct jitter_parameter ** const ps,bool enable_fast_literals)8811 pvm_recognize_specialized_instruction_popod (struct jitter_parameter ** const ps,
8812 bool enable_fast_literals)
8813 {
8814 /* The prefix is a full specialized instruction. We're done recognizing it. */
8815 return pvm_specialized_instruction_opcode_popod;
8816 }
8817
8818 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_popoi(struct jitter_parameter ** const ps,bool enable_fast_literals)8819 pvm_recognize_specialized_instruction_popoi (struct jitter_parameter ** const ps,
8820 bool enable_fast_literals)
8821 {
8822 /* The prefix is a full specialized instruction. We're done recognizing it. */
8823 return pvm_specialized_instruction_opcode_popoi;
8824 }
8825
8826 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_popom(struct jitter_parameter ** const ps,bool enable_fast_literals)8827 pvm_recognize_specialized_instruction_popom (struct jitter_parameter ** const ps,
8828 bool enable_fast_literals)
8829 {
8830 /* The prefix is a full specialized instruction. We're done recognizing it. */
8831 return pvm_specialized_instruction_opcode_popom;
8832 }
8833
8834 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_popoo(struct jitter_parameter ** const ps,bool enable_fast_literals)8835 pvm_recognize_specialized_instruction_popoo (struct jitter_parameter ** const ps,
8836 bool enable_fast_literals)
8837 {
8838 /* The prefix is a full specialized instruction. We're done recognizing it. */
8839 return pvm_specialized_instruction_opcode_popoo;
8840 }
8841
8842 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_popopp(struct jitter_parameter ** const ps,bool enable_fast_literals)8843 pvm_recognize_specialized_instruction_popopp (struct jitter_parameter ** const ps,
8844 bool enable_fast_literals)
8845 {
8846 /* The prefix is a full specialized instruction. We're done recognizing it. */
8847 return pvm_specialized_instruction_opcode_popopp;
8848 }
8849
8850 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_popr(struct jitter_parameter ** const ps,bool enable_fast_literals)8851 pvm_recognize_specialized_instruction_popr (struct jitter_parameter ** const ps,
8852 bool enable_fast_literals)
8853 {
8854 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8855 if (((* ps)->type == jitter_parameter_type_register_id)
8856 && (res = pvm_recognize_specialized_instruction_popr___rrR (ps + 1, enable_fast_literals)))
8857 goto done;
8858 done:
8859 return res;
8860 }
8861
8862 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_popr___rrR(struct jitter_parameter ** const ps,bool enable_fast_literals)8863 pvm_recognize_specialized_instruction_popr___rrR (struct jitter_parameter ** const ps,
8864 bool enable_fast_literals)
8865 {
8866 /* The prefix is a full specialized instruction. We're done recognizing it. */
8867 return pvm_specialized_instruction_opcode_popr___rrR;
8868 }
8869
8870 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_popvar(struct jitter_parameter ** const ps,bool enable_fast_literals)8871 pvm_recognize_specialized_instruction_popvar (struct jitter_parameter ** const ps,
8872 bool enable_fast_literals)
8873 {
8874 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8875 if (((* ps)->type == jitter_parameter_type_literal)
8876 && (res = pvm_recognize_specialized_instruction_popvar__nR (ps + 1, enable_fast_literals)))
8877 goto done;
8878 done:
8879 return res;
8880 }
8881
8882 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_popvar__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8883 pvm_recognize_specialized_instruction_popvar__nR (struct jitter_parameter ** const ps,
8884 bool enable_fast_literals)
8885 {
8886 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8887 if (((* ps)->type == jitter_parameter_type_literal)
8888 && (res = pvm_recognize_specialized_instruction_popvar__nR__nR (ps + 1, enable_fast_literals)))
8889 goto done;
8890 done:
8891 return res;
8892 }
8893
8894 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_popvar__nR__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8895 pvm_recognize_specialized_instruction_popvar__nR__nR (struct jitter_parameter ** const ps,
8896 bool enable_fast_literals)
8897 {
8898 /* The prefix is a full specialized instruction. We're done recognizing it. */
8899 return pvm_specialized_instruction_opcode_popvar__nR__nR;
8900 }
8901
8902 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_powi(struct jitter_parameter ** const ps,bool enable_fast_literals)8903 pvm_recognize_specialized_instruction_powi (struct jitter_parameter ** const ps,
8904 bool enable_fast_literals)
8905 {
8906 /* The prefix is a full specialized instruction. We're done recognizing it. */
8907 return pvm_specialized_instruction_opcode_powi;
8908 }
8909
8910 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_powiu(struct jitter_parameter ** const ps,bool enable_fast_literals)8911 pvm_recognize_specialized_instruction_powiu (struct jitter_parameter ** const ps,
8912 bool enable_fast_literals)
8913 {
8914 /* The prefix is a full specialized instruction. We're done recognizing it. */
8915 return pvm_specialized_instruction_opcode_powiu;
8916 }
8917
8918 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_powl(struct jitter_parameter ** const ps,bool enable_fast_literals)8919 pvm_recognize_specialized_instruction_powl (struct jitter_parameter ** const ps,
8920 bool enable_fast_literals)
8921 {
8922 /* The prefix is a full specialized instruction. We're done recognizing it. */
8923 return pvm_specialized_instruction_opcode_powl;
8924 }
8925
8926 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_powlu(struct jitter_parameter ** const ps,bool enable_fast_literals)8927 pvm_recognize_specialized_instruction_powlu (struct jitter_parameter ** const ps,
8928 bool enable_fast_literals)
8929 {
8930 /* The prefix is a full specialized instruction. We're done recognizing it. */
8931 return pvm_specialized_instruction_opcode_powlu;
8932 }
8933
8934 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_printi(struct jitter_parameter ** const ps,bool enable_fast_literals)8935 pvm_recognize_specialized_instruction_printi (struct jitter_parameter ** const ps,
8936 bool enable_fast_literals)
8937 {
8938 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8939 if (((* ps)->type == jitter_parameter_type_literal)
8940 && (res = pvm_recognize_specialized_instruction_printi__nR (ps + 1, enable_fast_literals)))
8941 goto done;
8942 done:
8943 return res;
8944 }
8945
8946 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_printi__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8947 pvm_recognize_specialized_instruction_printi__nR (struct jitter_parameter ** const ps,
8948 bool enable_fast_literals)
8949 {
8950 /* The prefix is a full specialized instruction. We're done recognizing it. */
8951 return pvm_specialized_instruction_opcode_printi__nR;
8952 }
8953
8954 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_printiu(struct jitter_parameter ** const ps,bool enable_fast_literals)8955 pvm_recognize_specialized_instruction_printiu (struct jitter_parameter ** const ps,
8956 bool enable_fast_literals)
8957 {
8958 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8959 if (((* ps)->type == jitter_parameter_type_literal)
8960 && (res = pvm_recognize_specialized_instruction_printiu__nR (ps + 1, enable_fast_literals)))
8961 goto done;
8962 done:
8963 return res;
8964 }
8965
8966 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_printiu__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8967 pvm_recognize_specialized_instruction_printiu__nR (struct jitter_parameter ** const ps,
8968 bool enable_fast_literals)
8969 {
8970 /* The prefix is a full specialized instruction. We're done recognizing it. */
8971 return pvm_specialized_instruction_opcode_printiu__nR;
8972 }
8973
8974 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_printl(struct jitter_parameter ** const ps,bool enable_fast_literals)8975 pvm_recognize_specialized_instruction_printl (struct jitter_parameter ** const ps,
8976 bool enable_fast_literals)
8977 {
8978 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8979 if (((* ps)->type == jitter_parameter_type_literal)
8980 && (res = pvm_recognize_specialized_instruction_printl__nR (ps + 1, enable_fast_literals)))
8981 goto done;
8982 done:
8983 return res;
8984 }
8985
8986 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_printl__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)8987 pvm_recognize_specialized_instruction_printl__nR (struct jitter_parameter ** const ps,
8988 bool enable_fast_literals)
8989 {
8990 /* The prefix is a full specialized instruction. We're done recognizing it. */
8991 return pvm_specialized_instruction_opcode_printl__nR;
8992 }
8993
8994 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_printlu(struct jitter_parameter ** const ps,bool enable_fast_literals)8995 pvm_recognize_specialized_instruction_printlu (struct jitter_parameter ** const ps,
8996 bool enable_fast_literals)
8997 {
8998 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
8999 if (((* ps)->type == jitter_parameter_type_literal)
9000 && (res = pvm_recognize_specialized_instruction_printlu__nR (ps + 1, enable_fast_literals)))
9001 goto done;
9002 done:
9003 return res;
9004 }
9005
9006 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_printlu__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)9007 pvm_recognize_specialized_instruction_printlu__nR (struct jitter_parameter ** const ps,
9008 bool enable_fast_literals)
9009 {
9010 /* The prefix is a full specialized instruction. We're done recognizing it. */
9011 return pvm_specialized_instruction_opcode_printlu__nR;
9012 }
9013
9014 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_prints(struct jitter_parameter ** const ps,bool enable_fast_literals)9015 pvm_recognize_specialized_instruction_prints (struct jitter_parameter ** const ps,
9016 bool enable_fast_literals)
9017 {
9018 /* The prefix is a full specialized instruction. We're done recognizing it. */
9019 return pvm_specialized_instruction_opcode_prints;
9020 }
9021
9022 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_prolog(struct jitter_parameter ** const ps,bool enable_fast_literals)9023 pvm_recognize_specialized_instruction_prolog (struct jitter_parameter ** const ps,
9024 bool enable_fast_literals)
9025 {
9026 /* The prefix is a full specialized instruction. We're done recognizing it. */
9027 return pvm_specialized_instruction_opcode_prolog;
9028 }
9029
9030 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_push(struct jitter_parameter ** const ps,bool enable_fast_literals)9031 pvm_recognize_specialized_instruction_push (struct jitter_parameter ** const ps,
9032 bool enable_fast_literals)
9033 {
9034 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
9035 if (((* ps)->type == jitter_parameter_type_literal)
9036 && (res = pvm_recognize_specialized_instruction_push__nR (ps + 1, enable_fast_literals)))
9037 goto done;
9038 if (((* ps)->type == jitter_parameter_type_label)
9039 && (res = pvm_recognize_specialized_instruction_push__lR (ps + 1, enable_fast_literals)))
9040 goto done;
9041 done:
9042 return res;
9043 }
9044
9045 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_push__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)9046 pvm_recognize_specialized_instruction_push__nR (struct jitter_parameter ** const ps,
9047 bool enable_fast_literals)
9048 {
9049 /* The prefix is a full specialized instruction. We're done recognizing it. */
9050 return pvm_specialized_instruction_opcode_push__nR;
9051 }
9052
9053 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_push__lR(struct jitter_parameter ** const ps,bool enable_fast_literals)9054 pvm_recognize_specialized_instruction_push__lR (struct jitter_parameter ** const ps,
9055 bool enable_fast_literals)
9056 {
9057 /* The prefix is a full specialized instruction. We're done recognizing it. */
9058 return pvm_specialized_instruction_opcode_push__lR;
9059 }
9060
9061 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_push32(struct jitter_parameter ** const ps,bool enable_fast_literals)9062 pvm_recognize_specialized_instruction_push32 (struct jitter_parameter ** const ps,
9063 bool enable_fast_literals)
9064 {
9065 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
9066 if (((* ps)->type == jitter_parameter_type_literal)
9067 && (res = pvm_recognize_specialized_instruction_push32__nR (ps + 1, enable_fast_literals)))
9068 goto done;
9069 if (((* ps)->type == jitter_parameter_type_label)
9070 && (res = pvm_recognize_specialized_instruction_push32__lR (ps + 1, enable_fast_literals)))
9071 goto done;
9072 done:
9073 return res;
9074 }
9075
9076 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_push32__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)9077 pvm_recognize_specialized_instruction_push32__nR (struct jitter_parameter ** const ps,
9078 bool enable_fast_literals)
9079 {
9080 /* The prefix is a full specialized instruction. We're done recognizing it. */
9081 return pvm_specialized_instruction_opcode_push32__nR;
9082 }
9083
9084 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_push32__lR(struct jitter_parameter ** const ps,bool enable_fast_literals)9085 pvm_recognize_specialized_instruction_push32__lR (struct jitter_parameter ** const ps,
9086 bool enable_fast_literals)
9087 {
9088 /* The prefix is a full specialized instruction. We're done recognizing it. */
9089 return pvm_specialized_instruction_opcode_push32__lR;
9090 }
9091
9092 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushe(struct jitter_parameter ** const ps,bool enable_fast_literals)9093 pvm_recognize_specialized_instruction_pushe (struct jitter_parameter ** const ps,
9094 bool enable_fast_literals)
9095 {
9096 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
9097 if (((* ps)->type == jitter_parameter_type_label)
9098 && (res = pvm_recognize_specialized_instruction_pushe__lR (ps + 1, enable_fast_literals)))
9099 goto done;
9100 done:
9101 return res;
9102 }
9103
9104 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushe__lR(struct jitter_parameter ** const ps,bool enable_fast_literals)9105 pvm_recognize_specialized_instruction_pushe__lR (struct jitter_parameter ** const ps,
9106 bool enable_fast_literals)
9107 {
9108 /* The prefix is a full specialized instruction. We're done recognizing it. */
9109 return pvm_specialized_instruction_opcode_pushe__lR;
9110 }
9111
9112 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushend(struct jitter_parameter ** const ps,bool enable_fast_literals)9113 pvm_recognize_specialized_instruction_pushend (struct jitter_parameter ** const ps,
9114 bool enable_fast_literals)
9115 {
9116 /* The prefix is a full specialized instruction. We're done recognizing it. */
9117 return pvm_specialized_instruction_opcode_pushend;
9118 }
9119
9120 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushf(struct jitter_parameter ** const ps,bool enable_fast_literals)9121 pvm_recognize_specialized_instruction_pushf (struct jitter_parameter ** const ps,
9122 bool enable_fast_literals)
9123 {
9124 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
9125 if (((* ps)->type == jitter_parameter_type_literal)
9126 && (res = pvm_recognize_specialized_instruction_pushf__nR (ps + 1, enable_fast_literals)))
9127 goto done;
9128 done:
9129 return res;
9130 }
9131
9132 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushf__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)9133 pvm_recognize_specialized_instruction_pushf__nR (struct jitter_parameter ** const ps,
9134 bool enable_fast_literals)
9135 {
9136 /* The prefix is a full specialized instruction. We're done recognizing it. */
9137 return pvm_specialized_instruction_opcode_pushf__nR;
9138 }
9139
9140 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushhi(struct jitter_parameter ** const ps,bool enable_fast_literals)9141 pvm_recognize_specialized_instruction_pushhi (struct jitter_parameter ** const ps,
9142 bool enable_fast_literals)
9143 {
9144 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
9145 if (((* ps)->type == jitter_parameter_type_literal)
9146 && (res = pvm_recognize_specialized_instruction_pushhi__nR (ps + 1, enable_fast_literals)))
9147 goto done;
9148 if (((* ps)->type == jitter_parameter_type_label)
9149 && (res = pvm_recognize_specialized_instruction_pushhi__lR (ps + 1, enable_fast_literals)))
9150 goto done;
9151 done:
9152 return res;
9153 }
9154
9155 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushhi__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)9156 pvm_recognize_specialized_instruction_pushhi__nR (struct jitter_parameter ** const ps,
9157 bool enable_fast_literals)
9158 {
9159 /* The prefix is a full specialized instruction. We're done recognizing it. */
9160 return pvm_specialized_instruction_opcode_pushhi__nR;
9161 }
9162
9163 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushhi__lR(struct jitter_parameter ** const ps,bool enable_fast_literals)9164 pvm_recognize_specialized_instruction_pushhi__lR (struct jitter_parameter ** const ps,
9165 bool enable_fast_literals)
9166 {
9167 /* The prefix is a full specialized instruction. We're done recognizing it. */
9168 return pvm_specialized_instruction_opcode_pushhi__lR;
9169 }
9170
9171 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushios(struct jitter_parameter ** const ps,bool enable_fast_literals)9172 pvm_recognize_specialized_instruction_pushios (struct jitter_parameter ** const ps,
9173 bool enable_fast_literals)
9174 {
9175 /* The prefix is a full specialized instruction. We're done recognizing it. */
9176 return pvm_specialized_instruction_opcode_pushios;
9177 }
9178
9179 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushlo(struct jitter_parameter ** const ps,bool enable_fast_literals)9180 pvm_recognize_specialized_instruction_pushlo (struct jitter_parameter ** const ps,
9181 bool enable_fast_literals)
9182 {
9183 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
9184 if (((* ps)->type == jitter_parameter_type_literal)
9185 && (res = pvm_recognize_specialized_instruction_pushlo__nR (ps + 1, enable_fast_literals)))
9186 goto done;
9187 if (((* ps)->type == jitter_parameter_type_label)
9188 && (res = pvm_recognize_specialized_instruction_pushlo__lR (ps + 1, enable_fast_literals)))
9189 goto done;
9190 done:
9191 return res;
9192 }
9193
9194 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushlo__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)9195 pvm_recognize_specialized_instruction_pushlo__nR (struct jitter_parameter ** const ps,
9196 bool enable_fast_literals)
9197 {
9198 /* The prefix is a full specialized instruction. We're done recognizing it. */
9199 return pvm_specialized_instruction_opcode_pushlo__nR;
9200 }
9201
9202 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushlo__lR(struct jitter_parameter ** const ps,bool enable_fast_literals)9203 pvm_recognize_specialized_instruction_pushlo__lR (struct jitter_parameter ** const ps,
9204 bool enable_fast_literals)
9205 {
9206 /* The prefix is a full specialized instruction. We're done recognizing it. */
9207 return pvm_specialized_instruction_opcode_pushlo__lR;
9208 }
9209
9210 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushoac(struct jitter_parameter ** const ps,bool enable_fast_literals)9211 pvm_recognize_specialized_instruction_pushoac (struct jitter_parameter ** const ps,
9212 bool enable_fast_literals)
9213 {
9214 /* The prefix is a full specialized instruction. We're done recognizing it. */
9215 return pvm_specialized_instruction_opcode_pushoac;
9216 }
9217
9218 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushob(struct jitter_parameter ** const ps,bool enable_fast_literals)9219 pvm_recognize_specialized_instruction_pushob (struct jitter_parameter ** const ps,
9220 bool enable_fast_literals)
9221 {
9222 /* The prefix is a full specialized instruction. We're done recognizing it. */
9223 return pvm_specialized_instruction_opcode_pushob;
9224 }
9225
9226 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushobc(struct jitter_parameter ** const ps,bool enable_fast_literals)9227 pvm_recognize_specialized_instruction_pushobc (struct jitter_parameter ** const ps,
9228 bool enable_fast_literals)
9229 {
9230 /* The prefix is a full specialized instruction. We're done recognizing it. */
9231 return pvm_specialized_instruction_opcode_pushobc;
9232 }
9233
9234 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushoc(struct jitter_parameter ** const ps,bool enable_fast_literals)9235 pvm_recognize_specialized_instruction_pushoc (struct jitter_parameter ** const ps,
9236 bool enable_fast_literals)
9237 {
9238 /* The prefix is a full specialized instruction. We're done recognizing it. */
9239 return pvm_specialized_instruction_opcode_pushoc;
9240 }
9241
9242 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushod(struct jitter_parameter ** const ps,bool enable_fast_literals)9243 pvm_recognize_specialized_instruction_pushod (struct jitter_parameter ** const ps,
9244 bool enable_fast_literals)
9245 {
9246 /* The prefix is a full specialized instruction. We're done recognizing it. */
9247 return pvm_specialized_instruction_opcode_pushod;
9248 }
9249
9250 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushoi(struct jitter_parameter ** const ps,bool enable_fast_literals)9251 pvm_recognize_specialized_instruction_pushoi (struct jitter_parameter ** const ps,
9252 bool enable_fast_literals)
9253 {
9254 /* The prefix is a full specialized instruction. We're done recognizing it. */
9255 return pvm_specialized_instruction_opcode_pushoi;
9256 }
9257
9258 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushom(struct jitter_parameter ** const ps,bool enable_fast_literals)9259 pvm_recognize_specialized_instruction_pushom (struct jitter_parameter ** const ps,
9260 bool enable_fast_literals)
9261 {
9262 /* The prefix is a full specialized instruction. We're done recognizing it. */
9263 return pvm_specialized_instruction_opcode_pushom;
9264 }
9265
9266 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushoo(struct jitter_parameter ** const ps,bool enable_fast_literals)9267 pvm_recognize_specialized_instruction_pushoo (struct jitter_parameter ** const ps,
9268 bool enable_fast_literals)
9269 {
9270 /* The prefix is a full specialized instruction. We're done recognizing it. */
9271 return pvm_specialized_instruction_opcode_pushoo;
9272 }
9273
9274 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushopp(struct jitter_parameter ** const ps,bool enable_fast_literals)9275 pvm_recognize_specialized_instruction_pushopp (struct jitter_parameter ** const ps,
9276 bool enable_fast_literals)
9277 {
9278 /* The prefix is a full specialized instruction. We're done recognizing it. */
9279 return pvm_specialized_instruction_opcode_pushopp;
9280 }
9281
9282 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushr(struct jitter_parameter ** const ps,bool enable_fast_literals)9283 pvm_recognize_specialized_instruction_pushr (struct jitter_parameter ** const ps,
9284 bool enable_fast_literals)
9285 {
9286 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
9287 if (((* ps)->type == jitter_parameter_type_register_id)
9288 && (res = pvm_recognize_specialized_instruction_pushr___rrR (ps + 1, enable_fast_literals)))
9289 goto done;
9290 done:
9291 return res;
9292 }
9293
9294 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushr___rrR(struct jitter_parameter ** const ps,bool enable_fast_literals)9295 pvm_recognize_specialized_instruction_pushr___rrR (struct jitter_parameter ** const ps,
9296 bool enable_fast_literals)
9297 {
9298 /* The prefix is a full specialized instruction. We're done recognizing it. */
9299 return pvm_specialized_instruction_opcode_pushr___rrR;
9300 }
9301
9302 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushtopvar(struct jitter_parameter ** const ps,bool enable_fast_literals)9303 pvm_recognize_specialized_instruction_pushtopvar (struct jitter_parameter ** const ps,
9304 bool enable_fast_literals)
9305 {
9306 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
9307 if (((* ps)->type == jitter_parameter_type_literal)
9308 && (res = pvm_recognize_specialized_instruction_pushtopvar__nR (ps + 1, enable_fast_literals)))
9309 goto done;
9310 done:
9311 return res;
9312 }
9313
9314 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushtopvar__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)9315 pvm_recognize_specialized_instruction_pushtopvar__nR (struct jitter_parameter ** const ps,
9316 bool enable_fast_literals)
9317 {
9318 /* The prefix is a full specialized instruction. We're done recognizing it. */
9319 return pvm_specialized_instruction_opcode_pushtopvar__nR;
9320 }
9321
9322 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushvar(struct jitter_parameter ** const ps,bool enable_fast_literals)9323 pvm_recognize_specialized_instruction_pushvar (struct jitter_parameter ** const ps,
9324 bool enable_fast_literals)
9325 {
9326 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
9327 if (((* ps)->type == jitter_parameter_type_literal && (* ps)->literal.fixnum == 0 && enable_fast_literals)
9328 && (res = pvm_recognize_specialized_instruction_pushvar__n0 (ps + 1, enable_fast_literals)))
9329 goto done;
9330 if (((* ps)->type == jitter_parameter_type_literal)
9331 && (res = pvm_recognize_specialized_instruction_pushvar__nR (ps + 1, enable_fast_literals)))
9332 goto done;
9333 done:
9334 return res;
9335 }
9336
9337 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushvar__n0(struct jitter_parameter ** const ps,bool enable_fast_literals)9338 pvm_recognize_specialized_instruction_pushvar__n0 (struct jitter_parameter ** const ps,
9339 bool enable_fast_literals)
9340 {
9341 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
9342 if (((* ps)->type == jitter_parameter_type_literal && (* ps)->literal.fixnum == 0 && enable_fast_literals)
9343 && (res = pvm_recognize_specialized_instruction_pushvar__n0__n0 (ps + 1, enable_fast_literals)))
9344 goto done;
9345 if (((* ps)->type == jitter_parameter_type_literal && (* ps)->literal.fixnum == 1 && enable_fast_literals)
9346 && (res = pvm_recognize_specialized_instruction_pushvar__n0__n1 (ps + 1, enable_fast_literals)))
9347 goto done;
9348 if (((* ps)->type == jitter_parameter_type_literal && (* ps)->literal.fixnum == 2 && enable_fast_literals)
9349 && (res = pvm_recognize_specialized_instruction_pushvar__n0__n2 (ps + 1, enable_fast_literals)))
9350 goto done;
9351 if (((* ps)->type == jitter_parameter_type_literal && (* ps)->literal.fixnum == 3 && enable_fast_literals)
9352 && (res = pvm_recognize_specialized_instruction_pushvar__n0__n3 (ps + 1, enable_fast_literals)))
9353 goto done;
9354 if (((* ps)->type == jitter_parameter_type_literal && (* ps)->literal.fixnum == 4 && enable_fast_literals)
9355 && (res = pvm_recognize_specialized_instruction_pushvar__n0__n4 (ps + 1, enable_fast_literals)))
9356 goto done;
9357 if (((* ps)->type == jitter_parameter_type_literal && (* ps)->literal.fixnum == 5 && enable_fast_literals)
9358 && (res = pvm_recognize_specialized_instruction_pushvar__n0__n5 (ps + 1, enable_fast_literals)))
9359 goto done;
9360 if (((* ps)->type == jitter_parameter_type_literal)
9361 && (res = pvm_recognize_specialized_instruction_pushvar__n0__nR (ps + 1, enable_fast_literals)))
9362 goto done;
9363 done:
9364 return res;
9365 }
9366
9367 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushvar__n0__n0(struct jitter_parameter ** const ps,bool enable_fast_literals)9368 pvm_recognize_specialized_instruction_pushvar__n0__n0 (struct jitter_parameter ** const ps,
9369 bool enable_fast_literals)
9370 {
9371 /* The prefix is a full specialized instruction. We're done recognizing it. */
9372 return pvm_specialized_instruction_opcode_pushvar__n0__n0;
9373 }
9374
9375 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushvar__n0__n1(struct jitter_parameter ** const ps,bool enable_fast_literals)9376 pvm_recognize_specialized_instruction_pushvar__n0__n1 (struct jitter_parameter ** const ps,
9377 bool enable_fast_literals)
9378 {
9379 /* The prefix is a full specialized instruction. We're done recognizing it. */
9380 return pvm_specialized_instruction_opcode_pushvar__n0__n1;
9381 }
9382
9383 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushvar__n0__n2(struct jitter_parameter ** const ps,bool enable_fast_literals)9384 pvm_recognize_specialized_instruction_pushvar__n0__n2 (struct jitter_parameter ** const ps,
9385 bool enable_fast_literals)
9386 {
9387 /* The prefix is a full specialized instruction. We're done recognizing it. */
9388 return pvm_specialized_instruction_opcode_pushvar__n0__n2;
9389 }
9390
9391 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushvar__n0__n3(struct jitter_parameter ** const ps,bool enable_fast_literals)9392 pvm_recognize_specialized_instruction_pushvar__n0__n3 (struct jitter_parameter ** const ps,
9393 bool enable_fast_literals)
9394 {
9395 /* The prefix is a full specialized instruction. We're done recognizing it. */
9396 return pvm_specialized_instruction_opcode_pushvar__n0__n3;
9397 }
9398
9399 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushvar__n0__n4(struct jitter_parameter ** const ps,bool enable_fast_literals)9400 pvm_recognize_specialized_instruction_pushvar__n0__n4 (struct jitter_parameter ** const ps,
9401 bool enable_fast_literals)
9402 {
9403 /* The prefix is a full specialized instruction. We're done recognizing it. */
9404 return pvm_specialized_instruction_opcode_pushvar__n0__n4;
9405 }
9406
9407 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushvar__n0__n5(struct jitter_parameter ** const ps,bool enable_fast_literals)9408 pvm_recognize_specialized_instruction_pushvar__n0__n5 (struct jitter_parameter ** const ps,
9409 bool enable_fast_literals)
9410 {
9411 /* The prefix is a full specialized instruction. We're done recognizing it. */
9412 return pvm_specialized_instruction_opcode_pushvar__n0__n5;
9413 }
9414
9415 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushvar__n0__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)9416 pvm_recognize_specialized_instruction_pushvar__n0__nR (struct jitter_parameter ** const ps,
9417 bool enable_fast_literals)
9418 {
9419 /* The prefix is a full specialized instruction. We're done recognizing it. */
9420 return pvm_specialized_instruction_opcode_pushvar__n0__nR;
9421 }
9422
9423 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushvar__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)9424 pvm_recognize_specialized_instruction_pushvar__nR (struct jitter_parameter ** const ps,
9425 bool enable_fast_literals)
9426 {
9427 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
9428 if (((* ps)->type == jitter_parameter_type_literal && (* ps)->literal.fixnum == 0 && enable_fast_literals)
9429 && (res = pvm_recognize_specialized_instruction_pushvar__nR__n0 (ps + 1, enable_fast_literals)))
9430 goto done;
9431 if (((* ps)->type == jitter_parameter_type_literal && (* ps)->literal.fixnum == 1 && enable_fast_literals)
9432 && (res = pvm_recognize_specialized_instruction_pushvar__nR__n1 (ps + 1, enable_fast_literals)))
9433 goto done;
9434 if (((* ps)->type == jitter_parameter_type_literal && (* ps)->literal.fixnum == 2 && enable_fast_literals)
9435 && (res = pvm_recognize_specialized_instruction_pushvar__nR__n2 (ps + 1, enable_fast_literals)))
9436 goto done;
9437 if (((* ps)->type == jitter_parameter_type_literal && (* ps)->literal.fixnum == 3 && enable_fast_literals)
9438 && (res = pvm_recognize_specialized_instruction_pushvar__nR__n3 (ps + 1, enable_fast_literals)))
9439 goto done;
9440 if (((* ps)->type == jitter_parameter_type_literal && (* ps)->literal.fixnum == 4 && enable_fast_literals)
9441 && (res = pvm_recognize_specialized_instruction_pushvar__nR__n4 (ps + 1, enable_fast_literals)))
9442 goto done;
9443 if (((* ps)->type == jitter_parameter_type_literal && (* ps)->literal.fixnum == 5 && enable_fast_literals)
9444 && (res = pvm_recognize_specialized_instruction_pushvar__nR__n5 (ps + 1, enable_fast_literals)))
9445 goto done;
9446 if (((* ps)->type == jitter_parameter_type_literal)
9447 && (res = pvm_recognize_specialized_instruction_pushvar__nR__nR (ps + 1, enable_fast_literals)))
9448 goto done;
9449 done:
9450 return res;
9451 }
9452
9453 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushvar__nR__n0(struct jitter_parameter ** const ps,bool enable_fast_literals)9454 pvm_recognize_specialized_instruction_pushvar__nR__n0 (struct jitter_parameter ** const ps,
9455 bool enable_fast_literals)
9456 {
9457 /* The prefix is a full specialized instruction. We're done recognizing it. */
9458 return pvm_specialized_instruction_opcode_pushvar__nR__n0;
9459 }
9460
9461 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushvar__nR__n1(struct jitter_parameter ** const ps,bool enable_fast_literals)9462 pvm_recognize_specialized_instruction_pushvar__nR__n1 (struct jitter_parameter ** const ps,
9463 bool enable_fast_literals)
9464 {
9465 /* The prefix is a full specialized instruction. We're done recognizing it. */
9466 return pvm_specialized_instruction_opcode_pushvar__nR__n1;
9467 }
9468
9469 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushvar__nR__n2(struct jitter_parameter ** const ps,bool enable_fast_literals)9470 pvm_recognize_specialized_instruction_pushvar__nR__n2 (struct jitter_parameter ** const ps,
9471 bool enable_fast_literals)
9472 {
9473 /* The prefix is a full specialized instruction. We're done recognizing it. */
9474 return pvm_specialized_instruction_opcode_pushvar__nR__n2;
9475 }
9476
9477 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushvar__nR__n3(struct jitter_parameter ** const ps,bool enable_fast_literals)9478 pvm_recognize_specialized_instruction_pushvar__nR__n3 (struct jitter_parameter ** const ps,
9479 bool enable_fast_literals)
9480 {
9481 /* The prefix is a full specialized instruction. We're done recognizing it. */
9482 return pvm_specialized_instruction_opcode_pushvar__nR__n3;
9483 }
9484
9485 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushvar__nR__n4(struct jitter_parameter ** const ps,bool enable_fast_literals)9486 pvm_recognize_specialized_instruction_pushvar__nR__n4 (struct jitter_parameter ** const ps,
9487 bool enable_fast_literals)
9488 {
9489 /* The prefix is a full specialized instruction. We're done recognizing it. */
9490 return pvm_specialized_instruction_opcode_pushvar__nR__n4;
9491 }
9492
9493 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushvar__nR__n5(struct jitter_parameter ** const ps,bool enable_fast_literals)9494 pvm_recognize_specialized_instruction_pushvar__nR__n5 (struct jitter_parameter ** const ps,
9495 bool enable_fast_literals)
9496 {
9497 /* The prefix is a full specialized instruction. We're done recognizing it. */
9498 return pvm_specialized_instruction_opcode_pushvar__nR__n5;
9499 }
9500
9501 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_pushvar__nR__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)9502 pvm_recognize_specialized_instruction_pushvar__nR__nR (struct jitter_parameter ** const ps,
9503 bool enable_fast_literals)
9504 {
9505 /* The prefix is a full specialized instruction. We're done recognizing it. */
9506 return pvm_specialized_instruction_opcode_pushvar__nR__nR;
9507 }
9508
9509 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_quake(struct jitter_parameter ** const ps,bool enable_fast_literals)9510 pvm_recognize_specialized_instruction_quake (struct jitter_parameter ** const ps,
9511 bool enable_fast_literals)
9512 {
9513 /* The prefix is a full specialized instruction. We're done recognizing it. */
9514 return pvm_specialized_instruction_opcode_quake;
9515 }
9516
9517 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_raise(struct jitter_parameter ** const ps,bool enable_fast_literals)9518 pvm_recognize_specialized_instruction_raise (struct jitter_parameter ** const ps,
9519 bool enable_fast_literals)
9520 {
9521 /* The prefix is a full specialized instruction. We're done recognizing it. */
9522 return pvm_specialized_instruction_opcode_raise;
9523 }
9524
9525 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_rand(struct jitter_parameter ** const ps,bool enable_fast_literals)9526 pvm_recognize_specialized_instruction_rand (struct jitter_parameter ** const ps,
9527 bool enable_fast_literals)
9528 {
9529 /* The prefix is a full specialized instruction. We're done recognizing it. */
9530 return pvm_specialized_instruction_opcode_rand;
9531 }
9532
9533 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_regvar(struct jitter_parameter ** const ps,bool enable_fast_literals)9534 pvm_recognize_specialized_instruction_regvar (struct jitter_parameter ** const ps,
9535 bool enable_fast_literals)
9536 {
9537 /* The prefix is a full specialized instruction. We're done recognizing it. */
9538 return pvm_specialized_instruction_opcode_regvar;
9539 }
9540
9541 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_reloc(struct jitter_parameter ** const ps,bool enable_fast_literals)9542 pvm_recognize_specialized_instruction_reloc (struct jitter_parameter ** const ps,
9543 bool enable_fast_literals)
9544 {
9545 /* The prefix is a full specialized instruction. We're done recognizing it. */
9546 return pvm_specialized_instruction_opcode_reloc;
9547 }
9548
9549 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_restorer(struct jitter_parameter ** const ps,bool enable_fast_literals)9550 pvm_recognize_specialized_instruction_restorer (struct jitter_parameter ** const ps,
9551 bool enable_fast_literals)
9552 {
9553 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
9554 if (((* ps)->type == jitter_parameter_type_register_id)
9555 && (res = pvm_recognize_specialized_instruction_restorer___rrR (ps + 1, enable_fast_literals)))
9556 goto done;
9557 done:
9558 return res;
9559 }
9560
9561 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_restorer___rrR(struct jitter_parameter ** const ps,bool enable_fast_literals)9562 pvm_recognize_specialized_instruction_restorer___rrR (struct jitter_parameter ** const ps,
9563 bool enable_fast_literals)
9564 {
9565 /* The prefix is a full specialized instruction. We're done recognizing it. */
9566 return pvm_specialized_instruction_opcode_restorer___rrR;
9567 }
9568
9569 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_return(struct jitter_parameter ** const ps,bool enable_fast_literals)9570 pvm_recognize_specialized_instruction_return (struct jitter_parameter ** const ps,
9571 bool enable_fast_literals)
9572 {
9573 /* The prefix is a full specialized instruction. We're done recognizing it. */
9574 return pvm_specialized_instruction_opcode_return;
9575 }
9576
9577 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_revn(struct jitter_parameter ** const ps,bool enable_fast_literals)9578 pvm_recognize_specialized_instruction_revn (struct jitter_parameter ** const ps,
9579 bool enable_fast_literals)
9580 {
9581 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
9582 if (((* ps)->type == jitter_parameter_type_literal && (* ps)->literal.fixnum == 3 && enable_fast_literals)
9583 && (res = pvm_recognize_specialized_instruction_revn__n3 (ps + 1, enable_fast_literals)))
9584 goto done;
9585 if (((* ps)->type == jitter_parameter_type_literal && (* ps)->literal.fixnum == 4 && enable_fast_literals)
9586 && (res = pvm_recognize_specialized_instruction_revn__n4 (ps + 1, enable_fast_literals)))
9587 goto done;
9588 if (((* ps)->type == jitter_parameter_type_literal)
9589 && (res = pvm_recognize_specialized_instruction_revn__nR (ps + 1, enable_fast_literals)))
9590 goto done;
9591 done:
9592 return res;
9593 }
9594
9595 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_revn__n3(struct jitter_parameter ** const ps,bool enable_fast_literals)9596 pvm_recognize_specialized_instruction_revn__n3 (struct jitter_parameter ** const ps,
9597 bool enable_fast_literals)
9598 {
9599 /* The prefix is a full specialized instruction. We're done recognizing it. */
9600 return pvm_specialized_instruction_opcode_revn__n3;
9601 }
9602
9603 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_revn__n4(struct jitter_parameter ** const ps,bool enable_fast_literals)9604 pvm_recognize_specialized_instruction_revn__n4 (struct jitter_parameter ** const ps,
9605 bool enable_fast_literals)
9606 {
9607 /* The prefix is a full specialized instruction. We're done recognizing it. */
9608 return pvm_specialized_instruction_opcode_revn__n4;
9609 }
9610
9611 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_revn__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)9612 pvm_recognize_specialized_instruction_revn__nR (struct jitter_parameter ** const ps,
9613 bool enable_fast_literals)
9614 {
9615 /* The prefix is a full specialized instruction. We're done recognizing it. */
9616 return pvm_specialized_instruction_opcode_revn__nR;
9617 }
9618
9619 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_rot(struct jitter_parameter ** const ps,bool enable_fast_literals)9620 pvm_recognize_specialized_instruction_rot (struct jitter_parameter ** const ps,
9621 bool enable_fast_literals)
9622 {
9623 /* The prefix is a full specialized instruction. We're done recognizing it. */
9624 return pvm_specialized_instruction_opcode_rot;
9625 }
9626
9627 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_saver(struct jitter_parameter ** const ps,bool enable_fast_literals)9628 pvm_recognize_specialized_instruction_saver (struct jitter_parameter ** const ps,
9629 bool enable_fast_literals)
9630 {
9631 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
9632 if (((* ps)->type == jitter_parameter_type_register_id)
9633 && (res = pvm_recognize_specialized_instruction_saver___rrR (ps + 1, enable_fast_literals)))
9634 goto done;
9635 done:
9636 return res;
9637 }
9638
9639 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_saver___rrR(struct jitter_parameter ** const ps,bool enable_fast_literals)9640 pvm_recognize_specialized_instruction_saver___rrR (struct jitter_parameter ** const ps,
9641 bool enable_fast_literals)
9642 {
9643 /* The prefix is a full specialized instruction. We're done recognizing it. */
9644 return pvm_specialized_instruction_opcode_saver___rrR;
9645 }
9646
9647 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_sconc(struct jitter_parameter ** const ps,bool enable_fast_literals)9648 pvm_recognize_specialized_instruction_sconc (struct jitter_parameter ** const ps,
9649 bool enable_fast_literals)
9650 {
9651 /* The prefix is a full specialized instruction. We're done recognizing it. */
9652 return pvm_specialized_instruction_opcode_sconc;
9653 }
9654
9655 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_sel(struct jitter_parameter ** const ps,bool enable_fast_literals)9656 pvm_recognize_specialized_instruction_sel (struct jitter_parameter ** const ps,
9657 bool enable_fast_literals)
9658 {
9659 /* The prefix is a full specialized instruction. We're done recognizing it. */
9660 return pvm_specialized_instruction_opcode_sel;
9661 }
9662
9663 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_setr(struct jitter_parameter ** const ps,bool enable_fast_literals)9664 pvm_recognize_specialized_instruction_setr (struct jitter_parameter ** const ps,
9665 bool enable_fast_literals)
9666 {
9667 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
9668 if (((* ps)->type == jitter_parameter_type_register_id)
9669 && (res = pvm_recognize_specialized_instruction_setr___rrR (ps + 1, enable_fast_literals)))
9670 goto done;
9671 done:
9672 return res;
9673 }
9674
9675 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_setr___rrR(struct jitter_parameter ** const ps,bool enable_fast_literals)9676 pvm_recognize_specialized_instruction_setr___rrR (struct jitter_parameter ** const ps,
9677 bool enable_fast_literals)
9678 {
9679 /* The prefix is a full specialized instruction. We're done recognizing it. */
9680 return pvm_specialized_instruction_opcode_setr___rrR;
9681 }
9682
9683 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_siz(struct jitter_parameter ** const ps,bool enable_fast_literals)9684 pvm_recognize_specialized_instruction_siz (struct jitter_parameter ** const ps,
9685 bool enable_fast_literals)
9686 {
9687 /* The prefix is a full specialized instruction. We're done recognizing it. */
9688 return pvm_specialized_instruction_opcode_siz;
9689 }
9690
9691 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_smodi(struct jitter_parameter ** const ps,bool enable_fast_literals)9692 pvm_recognize_specialized_instruction_smodi (struct jitter_parameter ** const ps,
9693 bool enable_fast_literals)
9694 {
9695 /* The prefix is a full specialized instruction. We're done recognizing it. */
9696 return pvm_specialized_instruction_opcode_smodi;
9697 }
9698
9699 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_sref(struct jitter_parameter ** const ps,bool enable_fast_literals)9700 pvm_recognize_specialized_instruction_sref (struct jitter_parameter ** const ps,
9701 bool enable_fast_literals)
9702 {
9703 /* The prefix is a full specialized instruction. We're done recognizing it. */
9704 return pvm_specialized_instruction_opcode_sref;
9705 }
9706
9707 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_srefi(struct jitter_parameter ** const ps,bool enable_fast_literals)9708 pvm_recognize_specialized_instruction_srefi (struct jitter_parameter ** const ps,
9709 bool enable_fast_literals)
9710 {
9711 /* The prefix is a full specialized instruction. We're done recognizing it. */
9712 return pvm_specialized_instruction_opcode_srefi;
9713 }
9714
9715 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_srefia(struct jitter_parameter ** const ps,bool enable_fast_literals)9716 pvm_recognize_specialized_instruction_srefia (struct jitter_parameter ** const ps,
9717 bool enable_fast_literals)
9718 {
9719 /* The prefix is a full specialized instruction. We're done recognizing it. */
9720 return pvm_specialized_instruction_opcode_srefia;
9721 }
9722
9723 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_srefio(struct jitter_parameter ** const ps,bool enable_fast_literals)9724 pvm_recognize_specialized_instruction_srefio (struct jitter_parameter ** const ps,
9725 bool enable_fast_literals)
9726 {
9727 /* The prefix is a full specialized instruction. We're done recognizing it. */
9728 return pvm_specialized_instruction_opcode_srefio;
9729 }
9730
9731 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_srefmnt(struct jitter_parameter ** const ps,bool enable_fast_literals)9732 pvm_recognize_specialized_instruction_srefmnt (struct jitter_parameter ** const ps,
9733 bool enable_fast_literals)
9734 {
9735 /* The prefix is a full specialized instruction. We're done recognizing it. */
9736 return pvm_specialized_instruction_opcode_srefmnt;
9737 }
9738
9739 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_srefnt(struct jitter_parameter ** const ps,bool enable_fast_literals)9740 pvm_recognize_specialized_instruction_srefnt (struct jitter_parameter ** const ps,
9741 bool enable_fast_literals)
9742 {
9743 /* The prefix is a full specialized instruction. We're done recognizing it. */
9744 return pvm_specialized_instruction_opcode_srefnt;
9745 }
9746
9747 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_srefo(struct jitter_parameter ** const ps,bool enable_fast_literals)9748 pvm_recognize_specialized_instruction_srefo (struct jitter_parameter ** const ps,
9749 bool enable_fast_literals)
9750 {
9751 /* The prefix is a full specialized instruction. We're done recognizing it. */
9752 return pvm_specialized_instruction_opcode_srefo;
9753 }
9754
9755 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_sset(struct jitter_parameter ** const ps,bool enable_fast_literals)9756 pvm_recognize_specialized_instruction_sset (struct jitter_parameter ** const ps,
9757 bool enable_fast_literals)
9758 {
9759 /* The prefix is a full specialized instruction. We're done recognizing it. */
9760 return pvm_specialized_instruction_opcode_sset;
9761 }
9762
9763 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_strace(struct jitter_parameter ** const ps,bool enable_fast_literals)9764 pvm_recognize_specialized_instruction_strace (struct jitter_parameter ** const ps,
9765 bool enable_fast_literals)
9766 {
9767 enum pvm_specialized_instruction_opcode res = pvm_specialized_instruction_opcode__eINVALID;
9768 if (((* ps)->type == jitter_parameter_type_literal)
9769 && (res = pvm_recognize_specialized_instruction_strace__nR (ps + 1, enable_fast_literals)))
9770 goto done;
9771 done:
9772 return res;
9773 }
9774
9775 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_strace__nR(struct jitter_parameter ** const ps,bool enable_fast_literals)9776 pvm_recognize_specialized_instruction_strace__nR (struct jitter_parameter ** const ps,
9777 bool enable_fast_literals)
9778 {
9779 /* The prefix is a full specialized instruction. We're done recognizing it. */
9780 return pvm_specialized_instruction_opcode_strace__nR;
9781 }
9782
9783 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_strref(struct jitter_parameter ** const ps,bool enable_fast_literals)9784 pvm_recognize_specialized_instruction_strref (struct jitter_parameter ** const ps,
9785 bool enable_fast_literals)
9786 {
9787 /* The prefix is a full specialized instruction. We're done recognizing it. */
9788 return pvm_specialized_instruction_opcode_strref;
9789 }
9790
9791 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_subi(struct jitter_parameter ** const ps,bool enable_fast_literals)9792 pvm_recognize_specialized_instruction_subi (struct jitter_parameter ** const ps,
9793 bool enable_fast_literals)
9794 {
9795 /* The prefix is a full specialized instruction. We're done recognizing it. */
9796 return pvm_specialized_instruction_opcode_subi;
9797 }
9798
9799 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_subiu(struct jitter_parameter ** const ps,bool enable_fast_literals)9800 pvm_recognize_specialized_instruction_subiu (struct jitter_parameter ** const ps,
9801 bool enable_fast_literals)
9802 {
9803 /* The prefix is a full specialized instruction. We're done recognizing it. */
9804 return pvm_specialized_instruction_opcode_subiu;
9805 }
9806
9807 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_subl(struct jitter_parameter ** const ps,bool enable_fast_literals)9808 pvm_recognize_specialized_instruction_subl (struct jitter_parameter ** const ps,
9809 bool enable_fast_literals)
9810 {
9811 /* The prefix is a full specialized instruction. We're done recognizing it. */
9812 return pvm_specialized_instruction_opcode_subl;
9813 }
9814
9815 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_sublu(struct jitter_parameter ** const ps,bool enable_fast_literals)9816 pvm_recognize_specialized_instruction_sublu (struct jitter_parameter ** const ps,
9817 bool enable_fast_literals)
9818 {
9819 /* The prefix is a full specialized instruction. We're done recognizing it. */
9820 return pvm_specialized_instruction_opcode_sublu;
9821 }
9822
9823 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_substr(struct jitter_parameter ** const ps,bool enable_fast_literals)9824 pvm_recognize_specialized_instruction_substr (struct jitter_parameter ** const ps,
9825 bool enable_fast_literals)
9826 {
9827 /* The prefix is a full specialized instruction. We're done recognizing it. */
9828 return pvm_specialized_instruction_opcode_substr;
9829 }
9830
9831 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_swap(struct jitter_parameter ** const ps,bool enable_fast_literals)9832 pvm_recognize_specialized_instruction_swap (struct jitter_parameter ** const ps,
9833 bool enable_fast_literals)
9834 {
9835 /* The prefix is a full specialized instruction. We're done recognizing it. */
9836 return pvm_specialized_instruction_opcode_swap;
9837 }
9838
9839 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_swapgti(struct jitter_parameter ** const ps,bool enable_fast_literals)9840 pvm_recognize_specialized_instruction_swapgti (struct jitter_parameter ** const ps,
9841 bool enable_fast_literals)
9842 {
9843 /* The prefix is a full specialized instruction. We're done recognizing it. */
9844 return pvm_specialized_instruction_opcode_swapgti;
9845 }
9846
9847 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_swapgtiu(struct jitter_parameter ** const ps,bool enable_fast_literals)9848 pvm_recognize_specialized_instruction_swapgtiu (struct jitter_parameter ** const ps,
9849 bool enable_fast_literals)
9850 {
9851 /* The prefix is a full specialized instruction. We're done recognizing it. */
9852 return pvm_specialized_instruction_opcode_swapgtiu;
9853 }
9854
9855 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_swapgtl(struct jitter_parameter ** const ps,bool enable_fast_literals)9856 pvm_recognize_specialized_instruction_swapgtl (struct jitter_parameter ** const ps,
9857 bool enable_fast_literals)
9858 {
9859 /* The prefix is a full specialized instruction. We're done recognizing it. */
9860 return pvm_specialized_instruction_opcode_swapgtl;
9861 }
9862
9863 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_swapgtlu(struct jitter_parameter ** const ps,bool enable_fast_literals)9864 pvm_recognize_specialized_instruction_swapgtlu (struct jitter_parameter ** const ps,
9865 bool enable_fast_literals)
9866 {
9867 /* The prefix is a full specialized instruction. We're done recognizing it. */
9868 return pvm_specialized_instruction_opcode_swapgtlu;
9869 }
9870
9871 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_sync(struct jitter_parameter ** const ps,bool enable_fast_literals)9872 pvm_recognize_specialized_instruction_sync (struct jitter_parameter ** const ps,
9873 bool enable_fast_literals)
9874 {
9875 /* The prefix is a full specialized instruction. We're done recognizing it. */
9876 return pvm_specialized_instruction_opcode_sync;
9877 }
9878
9879 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_time(struct jitter_parameter ** const ps,bool enable_fast_literals)9880 pvm_recognize_specialized_instruction_time (struct jitter_parameter ** const ps,
9881 bool enable_fast_literals)
9882 {
9883 /* The prefix is a full specialized instruction. We're done recognizing it. */
9884 return pvm_specialized_instruction_opcode_time;
9885 }
9886
9887 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_tor(struct jitter_parameter ** const ps,bool enable_fast_literals)9888 pvm_recognize_specialized_instruction_tor (struct jitter_parameter ** const ps,
9889 bool enable_fast_literals)
9890 {
9891 /* The prefix is a full specialized instruction. We're done recognizing it. */
9892 return pvm_specialized_instruction_opcode_tor;
9893 }
9894
9895 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_tuck(struct jitter_parameter ** const ps,bool enable_fast_literals)9896 pvm_recognize_specialized_instruction_tuck (struct jitter_parameter ** const ps,
9897 bool enable_fast_literals)
9898 {
9899 /* The prefix is a full specialized instruction. We're done recognizing it. */
9900 return pvm_specialized_instruction_opcode_tuck;
9901 }
9902
9903 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_tyagetb(struct jitter_parameter ** const ps,bool enable_fast_literals)9904 pvm_recognize_specialized_instruction_tyagetb (struct jitter_parameter ** const ps,
9905 bool enable_fast_literals)
9906 {
9907 /* The prefix is a full specialized instruction. We're done recognizing it. */
9908 return pvm_specialized_instruction_opcode_tyagetb;
9909 }
9910
9911 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_tyagett(struct jitter_parameter ** const ps,bool enable_fast_literals)9912 pvm_recognize_specialized_instruction_tyagett (struct jitter_parameter ** const ps,
9913 bool enable_fast_literals)
9914 {
9915 /* The prefix is a full specialized instruction. We're done recognizing it. */
9916 return pvm_specialized_instruction_opcode_tyagett;
9917 }
9918
9919 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_tyisc(struct jitter_parameter ** const ps,bool enable_fast_literals)9920 pvm_recognize_specialized_instruction_tyisc (struct jitter_parameter ** const ps,
9921 bool enable_fast_literals)
9922 {
9923 /* The prefix is a full specialized instruction. We're done recognizing it. */
9924 return pvm_specialized_instruction_opcode_tyisc;
9925 }
9926
9927 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_tyissct(struct jitter_parameter ** const ps,bool enable_fast_literals)9928 pvm_recognize_specialized_instruction_tyissct (struct jitter_parameter ** const ps,
9929 bool enable_fast_literals)
9930 {
9931 /* The prefix is a full specialized instruction. We're done recognizing it. */
9932 return pvm_specialized_instruction_opcode_tyissct;
9933 }
9934
9935 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_typof(struct jitter_parameter ** const ps,bool enable_fast_literals)9936 pvm_recognize_specialized_instruction_typof (struct jitter_parameter ** const ps,
9937 bool enable_fast_literals)
9938 {
9939 /* The prefix is a full specialized instruction. We're done recognizing it. */
9940 return pvm_specialized_instruction_opcode_typof;
9941 }
9942
9943 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_tysctn(struct jitter_parameter ** const ps,bool enable_fast_literals)9944 pvm_recognize_specialized_instruction_tysctn (struct jitter_parameter ** const ps,
9945 bool enable_fast_literals)
9946 {
9947 /* The prefix is a full specialized instruction. We're done recognizing it. */
9948 return pvm_specialized_instruction_opcode_tysctn;
9949 }
9950
9951 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_unmap(struct jitter_parameter ** const ps,bool enable_fast_literals)9952 pvm_recognize_specialized_instruction_unmap (struct jitter_parameter ** const ps,
9953 bool enable_fast_literals)
9954 {
9955 /* The prefix is a full specialized instruction. We're done recognizing it. */
9956 return pvm_specialized_instruction_opcode_unmap;
9957 }
9958
9959 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_unreachable(struct jitter_parameter ** const ps,bool enable_fast_literals)9960 pvm_recognize_specialized_instruction_unreachable (struct jitter_parameter ** const ps,
9961 bool enable_fast_literals)
9962 {
9963 /* The prefix is a full specialized instruction. We're done recognizing it. */
9964 return pvm_specialized_instruction_opcode_unreachable;
9965 }
9966
9967 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_ureloc(struct jitter_parameter ** const ps,bool enable_fast_literals)9968 pvm_recognize_specialized_instruction_ureloc (struct jitter_parameter ** const ps,
9969 bool enable_fast_literals)
9970 {
9971 /* The prefix is a full specialized instruction. We're done recognizing it. */
9972 return pvm_specialized_instruction_opcode_ureloc;
9973 }
9974
9975 inline static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction_write(struct jitter_parameter ** const ps,bool enable_fast_literals)9976 pvm_recognize_specialized_instruction_write (struct jitter_parameter ** const ps,
9977 bool enable_fast_literals)
9978 {
9979 /* The prefix is a full specialized instruction. We're done recognizing it. */
9980 return pvm_specialized_instruction_opcode_write__retR;
9981 }
9982
9983
9984
9985 /* Recognizer entry point. */
9986 static enum pvm_specialized_instruction_opcode
pvm_recognize_specialized_instruction(struct jitter_mutable_routine * p,const struct jitter_instruction * ins)9987 pvm_recognize_specialized_instruction (struct jitter_mutable_routine *p,
9988 const struct jitter_instruction *ins)
9989 {
9990 bool fl = ! p->options.slow_literals_only;
9991 const struct jitter_meta_instruction *mi = ins->meta_instruction;
9992 switch (mi->id)
9993 {
9994 case pvm_meta_instruction_id_addi:
9995 return pvm_recognize_specialized_instruction_addi (ins->parameters, fl);
9996 case pvm_meta_instruction_id_addiu:
9997 return pvm_recognize_specialized_instruction_addiu (ins->parameters, fl);
9998 case pvm_meta_instruction_id_addl:
9999 return pvm_recognize_specialized_instruction_addl (ins->parameters, fl);
10000 case pvm_meta_instruction_id_addlu:
10001 return pvm_recognize_specialized_instruction_addlu (ins->parameters, fl);
10002 case pvm_meta_instruction_id_ains:
10003 return pvm_recognize_specialized_instruction_ains (ins->parameters, fl);
10004 case pvm_meta_instruction_id_and:
10005 return pvm_recognize_specialized_instruction_and (ins->parameters, fl);
10006 case pvm_meta_instruction_id_aref:
10007 return pvm_recognize_specialized_instruction_aref (ins->parameters, fl);
10008 case pvm_meta_instruction_id_arefo:
10009 return pvm_recognize_specialized_instruction_arefo (ins->parameters, fl);
10010 case pvm_meta_instruction_id_arem:
10011 return pvm_recognize_specialized_instruction_arem (ins->parameters, fl);
10012 case pvm_meta_instruction_id_aset:
10013 return pvm_recognize_specialized_instruction_aset (ins->parameters, fl);
10014 case pvm_meta_instruction_id_asettb:
10015 return pvm_recognize_specialized_instruction_asettb (ins->parameters, fl);
10016 case pvm_meta_instruction_id_atr:
10017 return pvm_recognize_specialized_instruction_atr (ins->parameters, fl);
10018 case pvm_meta_instruction_id_ba:
10019 return pvm_recognize_specialized_instruction_ba (ins->parameters, fl);
10020 case pvm_meta_instruction_id_bandi:
10021 return pvm_recognize_specialized_instruction_bandi (ins->parameters, fl);
10022 case pvm_meta_instruction_id_bandiu:
10023 return pvm_recognize_specialized_instruction_bandiu (ins->parameters, fl);
10024 case pvm_meta_instruction_id_bandl:
10025 return pvm_recognize_specialized_instruction_bandl (ins->parameters, fl);
10026 case pvm_meta_instruction_id_bandlu:
10027 return pvm_recognize_specialized_instruction_bandlu (ins->parameters, fl);
10028 case pvm_meta_instruction_id_beghl:
10029 return pvm_recognize_specialized_instruction_beghl (ins->parameters, fl);
10030 case pvm_meta_instruction_id_begsc:
10031 return pvm_recognize_specialized_instruction_begsc (ins->parameters, fl);
10032 case pvm_meta_instruction_id_bn:
10033 return pvm_recognize_specialized_instruction_bn (ins->parameters, fl);
10034 case pvm_meta_instruction_id_bnn:
10035 return pvm_recognize_specialized_instruction_bnn (ins->parameters, fl);
10036 case pvm_meta_instruction_id_bnoti:
10037 return pvm_recognize_specialized_instruction_bnoti (ins->parameters, fl);
10038 case pvm_meta_instruction_id_bnotiu:
10039 return pvm_recognize_specialized_instruction_bnotiu (ins->parameters, fl);
10040 case pvm_meta_instruction_id_bnotl:
10041 return pvm_recognize_specialized_instruction_bnotl (ins->parameters, fl);
10042 case pvm_meta_instruction_id_bnotlu:
10043 return pvm_recognize_specialized_instruction_bnotlu (ins->parameters, fl);
10044 case pvm_meta_instruction_id_bnzi:
10045 return pvm_recognize_specialized_instruction_bnzi (ins->parameters, fl);
10046 case pvm_meta_instruction_id_bnziu:
10047 return pvm_recognize_specialized_instruction_bnziu (ins->parameters, fl);
10048 case pvm_meta_instruction_id_bnzl:
10049 return pvm_recognize_specialized_instruction_bnzl (ins->parameters, fl);
10050 case pvm_meta_instruction_id_bnzlu:
10051 return pvm_recognize_specialized_instruction_bnzlu (ins->parameters, fl);
10052 case pvm_meta_instruction_id_bori:
10053 return pvm_recognize_specialized_instruction_bori (ins->parameters, fl);
10054 case pvm_meta_instruction_id_boriu:
10055 return pvm_recognize_specialized_instruction_boriu (ins->parameters, fl);
10056 case pvm_meta_instruction_id_borl:
10057 return pvm_recognize_specialized_instruction_borl (ins->parameters, fl);
10058 case pvm_meta_instruction_id_borlu:
10059 return pvm_recognize_specialized_instruction_borlu (ins->parameters, fl);
10060 case pvm_meta_instruction_id_bsli:
10061 return pvm_recognize_specialized_instruction_bsli (ins->parameters, fl);
10062 case pvm_meta_instruction_id_bsliu:
10063 return pvm_recognize_specialized_instruction_bsliu (ins->parameters, fl);
10064 case pvm_meta_instruction_id_bsll:
10065 return pvm_recognize_specialized_instruction_bsll (ins->parameters, fl);
10066 case pvm_meta_instruction_id_bsllu:
10067 return pvm_recognize_specialized_instruction_bsllu (ins->parameters, fl);
10068 case pvm_meta_instruction_id_bsri:
10069 return pvm_recognize_specialized_instruction_bsri (ins->parameters, fl);
10070 case pvm_meta_instruction_id_bsriu:
10071 return pvm_recognize_specialized_instruction_bsriu (ins->parameters, fl);
10072 case pvm_meta_instruction_id_bsrl:
10073 return pvm_recognize_specialized_instruction_bsrl (ins->parameters, fl);
10074 case pvm_meta_instruction_id_bsrlu:
10075 return pvm_recognize_specialized_instruction_bsrlu (ins->parameters, fl);
10076 case pvm_meta_instruction_id_bxori:
10077 return pvm_recognize_specialized_instruction_bxori (ins->parameters, fl);
10078 case pvm_meta_instruction_id_bxoriu:
10079 return pvm_recognize_specialized_instruction_bxoriu (ins->parameters, fl);
10080 case pvm_meta_instruction_id_bxorl:
10081 return pvm_recognize_specialized_instruction_bxorl (ins->parameters, fl);
10082 case pvm_meta_instruction_id_bxorlu:
10083 return pvm_recognize_specialized_instruction_bxorlu (ins->parameters, fl);
10084 case pvm_meta_instruction_id_bzi:
10085 return pvm_recognize_specialized_instruction_bzi (ins->parameters, fl);
10086 case pvm_meta_instruction_id_bziu:
10087 return pvm_recognize_specialized_instruction_bziu (ins->parameters, fl);
10088 case pvm_meta_instruction_id_bzl:
10089 return pvm_recognize_specialized_instruction_bzl (ins->parameters, fl);
10090 case pvm_meta_instruction_id_bzlu:
10091 return pvm_recognize_specialized_instruction_bzlu (ins->parameters, fl);
10092 case pvm_meta_instruction_id_call:
10093 return pvm_recognize_specialized_instruction_call (ins->parameters, fl);
10094 case pvm_meta_instruction_id_canary:
10095 return pvm_recognize_specialized_instruction_canary (ins->parameters, fl);
10096 case pvm_meta_instruction_id_close:
10097 return pvm_recognize_specialized_instruction_close (ins->parameters, fl);
10098 case pvm_meta_instruction_id_ctos:
10099 return pvm_recognize_specialized_instruction_ctos (ins->parameters, fl);
10100 case pvm_meta_instruction_id_disas:
10101 return pvm_recognize_specialized_instruction_disas (ins->parameters, fl);
10102 case pvm_meta_instruction_id_divi:
10103 return pvm_recognize_specialized_instruction_divi (ins->parameters, fl);
10104 case pvm_meta_instruction_id_diviu:
10105 return pvm_recognize_specialized_instruction_diviu (ins->parameters, fl);
10106 case pvm_meta_instruction_id_divl:
10107 return pvm_recognize_specialized_instruction_divl (ins->parameters, fl);
10108 case pvm_meta_instruction_id_divlu:
10109 return pvm_recognize_specialized_instruction_divlu (ins->parameters, fl);
10110 case pvm_meta_instruction_id_drop:
10111 return pvm_recognize_specialized_instruction_drop (ins->parameters, fl);
10112 case pvm_meta_instruction_id_drop2:
10113 return pvm_recognize_specialized_instruction_drop2 (ins->parameters, fl);
10114 case pvm_meta_instruction_id_drop3:
10115 return pvm_recognize_specialized_instruction_drop3 (ins->parameters, fl);
10116 case pvm_meta_instruction_id_drop4:
10117 return pvm_recognize_specialized_instruction_drop4 (ins->parameters, fl);
10118 case pvm_meta_instruction_id_duc:
10119 return pvm_recognize_specialized_instruction_duc (ins->parameters, fl);
10120 case pvm_meta_instruction_id_dup:
10121 return pvm_recognize_specialized_instruction_dup (ins->parameters, fl);
10122 case pvm_meta_instruction_id_endhl:
10123 return pvm_recognize_specialized_instruction_endhl (ins->parameters, fl);
10124 case pvm_meta_instruction_id_endsc:
10125 return pvm_recognize_specialized_instruction_endsc (ins->parameters, fl);
10126 case pvm_meta_instruction_id_eqi:
10127 return pvm_recognize_specialized_instruction_eqi (ins->parameters, fl);
10128 case pvm_meta_instruction_id_eqiu:
10129 return pvm_recognize_specialized_instruction_eqiu (ins->parameters, fl);
10130 case pvm_meta_instruction_id_eql:
10131 return pvm_recognize_specialized_instruction_eql (ins->parameters, fl);
10132 case pvm_meta_instruction_id_eqlu:
10133 return pvm_recognize_specialized_instruction_eqlu (ins->parameters, fl);
10134 case pvm_meta_instruction_id_eqs:
10135 return pvm_recognize_specialized_instruction_eqs (ins->parameters, fl);
10136 case pvm_meta_instruction_id_exit:
10137 return pvm_recognize_specialized_instruction_exit (ins->parameters, fl);
10138 case pvm_meta_instruction_id_exitvm:
10139 return pvm_recognize_specialized_instruction_exitvm (ins->parameters, fl);
10140 case pvm_meta_instruction_id_flush:
10141 return pvm_recognize_specialized_instruction_flush (ins->parameters, fl);
10142 case pvm_meta_instruction_id_fromr:
10143 return pvm_recognize_specialized_instruction_fromr (ins->parameters, fl);
10144 case pvm_meta_instruction_id_gei:
10145 return pvm_recognize_specialized_instruction_gei (ins->parameters, fl);
10146 case pvm_meta_instruction_id_geiu:
10147 return pvm_recognize_specialized_instruction_geiu (ins->parameters, fl);
10148 case pvm_meta_instruction_id_gel:
10149 return pvm_recognize_specialized_instruction_gel (ins->parameters, fl);
10150 case pvm_meta_instruction_id_gelu:
10151 return pvm_recognize_specialized_instruction_gelu (ins->parameters, fl);
10152 case pvm_meta_instruction_id_ges:
10153 return pvm_recognize_specialized_instruction_ges (ins->parameters, fl);
10154 case pvm_meta_instruction_id_getenv:
10155 return pvm_recognize_specialized_instruction_getenv (ins->parameters, fl);
10156 case pvm_meta_instruction_id_gti:
10157 return pvm_recognize_specialized_instruction_gti (ins->parameters, fl);
10158 case pvm_meta_instruction_id_gtiu:
10159 return pvm_recognize_specialized_instruction_gtiu (ins->parameters, fl);
10160 case pvm_meta_instruction_id_gtl:
10161 return pvm_recognize_specialized_instruction_gtl (ins->parameters, fl);
10162 case pvm_meta_instruction_id_gtlu:
10163 return pvm_recognize_specialized_instruction_gtlu (ins->parameters, fl);
10164 case pvm_meta_instruction_id_gts:
10165 return pvm_recognize_specialized_instruction_gts (ins->parameters, fl);
10166 case pvm_meta_instruction_id_indent:
10167 return pvm_recognize_specialized_instruction_indent (ins->parameters, fl);
10168 case pvm_meta_instruction_id_iogetb:
10169 return pvm_recognize_specialized_instruction_iogetb (ins->parameters, fl);
10170 case pvm_meta_instruction_id_iosetb:
10171 return pvm_recognize_specialized_instruction_iosetb (ins->parameters, fl);
10172 case pvm_meta_instruction_id_iosize:
10173 return pvm_recognize_specialized_instruction_iosize (ins->parameters, fl);
10174 case pvm_meta_instruction_id_isa:
10175 return pvm_recognize_specialized_instruction_isa (ins->parameters, fl);
10176 case pvm_meta_instruction_id_itoi:
10177 return pvm_recognize_specialized_instruction_itoi (ins->parameters, fl);
10178 case pvm_meta_instruction_id_itoiu:
10179 return pvm_recognize_specialized_instruction_itoiu (ins->parameters, fl);
10180 case pvm_meta_instruction_id_itol:
10181 return pvm_recognize_specialized_instruction_itol (ins->parameters, fl);
10182 case pvm_meta_instruction_id_itolu:
10183 return pvm_recognize_specialized_instruction_itolu (ins->parameters, fl);
10184 case pvm_meta_instruction_id_iutoi:
10185 return pvm_recognize_specialized_instruction_iutoi (ins->parameters, fl);
10186 case pvm_meta_instruction_id_iutoiu:
10187 return pvm_recognize_specialized_instruction_iutoiu (ins->parameters, fl);
10188 case pvm_meta_instruction_id_iutol:
10189 return pvm_recognize_specialized_instruction_iutol (ins->parameters, fl);
10190 case pvm_meta_instruction_id_iutolu:
10191 return pvm_recognize_specialized_instruction_iutolu (ins->parameters, fl);
10192 case pvm_meta_instruction_id_lei:
10193 return pvm_recognize_specialized_instruction_lei (ins->parameters, fl);
10194 case pvm_meta_instruction_id_leiu:
10195 return pvm_recognize_specialized_instruction_leiu (ins->parameters, fl);
10196 case pvm_meta_instruction_id_lel:
10197 return pvm_recognize_specialized_instruction_lel (ins->parameters, fl);
10198 case pvm_meta_instruction_id_lelu:
10199 return pvm_recognize_specialized_instruction_lelu (ins->parameters, fl);
10200 case pvm_meta_instruction_id_les:
10201 return pvm_recognize_specialized_instruction_les (ins->parameters, fl);
10202 case pvm_meta_instruction_id_lti:
10203 return pvm_recognize_specialized_instruction_lti (ins->parameters, fl);
10204 case pvm_meta_instruction_id_ltiu:
10205 return pvm_recognize_specialized_instruction_ltiu (ins->parameters, fl);
10206 case pvm_meta_instruction_id_ltl:
10207 return pvm_recognize_specialized_instruction_ltl (ins->parameters, fl);
10208 case pvm_meta_instruction_id_ltlu:
10209 return pvm_recognize_specialized_instruction_ltlu (ins->parameters, fl);
10210 case pvm_meta_instruction_id_ltoi:
10211 return pvm_recognize_specialized_instruction_ltoi (ins->parameters, fl);
10212 case pvm_meta_instruction_id_ltoiu:
10213 return pvm_recognize_specialized_instruction_ltoiu (ins->parameters, fl);
10214 case pvm_meta_instruction_id_ltol:
10215 return pvm_recognize_specialized_instruction_ltol (ins->parameters, fl);
10216 case pvm_meta_instruction_id_ltolu:
10217 return pvm_recognize_specialized_instruction_ltolu (ins->parameters, fl);
10218 case pvm_meta_instruction_id_lts:
10219 return pvm_recognize_specialized_instruction_lts (ins->parameters, fl);
10220 case pvm_meta_instruction_id_lutoi:
10221 return pvm_recognize_specialized_instruction_lutoi (ins->parameters, fl);
10222 case pvm_meta_instruction_id_lutoiu:
10223 return pvm_recognize_specialized_instruction_lutoiu (ins->parameters, fl);
10224 case pvm_meta_instruction_id_lutol:
10225 return pvm_recognize_specialized_instruction_lutol (ins->parameters, fl);
10226 case pvm_meta_instruction_id_lutolu:
10227 return pvm_recognize_specialized_instruction_lutolu (ins->parameters, fl);
10228 case pvm_meta_instruction_id_map:
10229 return pvm_recognize_specialized_instruction_map (ins->parameters, fl);
10230 case pvm_meta_instruction_id_mgetios:
10231 return pvm_recognize_specialized_instruction_mgetios (ins->parameters, fl);
10232 case pvm_meta_instruction_id_mgetm:
10233 return pvm_recognize_specialized_instruction_mgetm (ins->parameters, fl);
10234 case pvm_meta_instruction_id_mgeto:
10235 return pvm_recognize_specialized_instruction_mgeto (ins->parameters, fl);
10236 case pvm_meta_instruction_id_mgets:
10237 return pvm_recognize_specialized_instruction_mgets (ins->parameters, fl);
10238 case pvm_meta_instruction_id_mgetsel:
10239 return pvm_recognize_specialized_instruction_mgetsel (ins->parameters, fl);
10240 case pvm_meta_instruction_id_mgetsiz:
10241 return pvm_recognize_specialized_instruction_mgetsiz (ins->parameters, fl);
10242 case pvm_meta_instruction_id_mgetw:
10243 return pvm_recognize_specialized_instruction_mgetw (ins->parameters, fl);
10244 case pvm_meta_instruction_id_mka:
10245 return pvm_recognize_specialized_instruction_mka (ins->parameters, fl);
10246 case pvm_meta_instruction_id_mko:
10247 return pvm_recognize_specialized_instruction_mko (ins->parameters, fl);
10248 case pvm_meta_instruction_id_mksct:
10249 return pvm_recognize_specialized_instruction_mksct (ins->parameters, fl);
10250 case pvm_meta_instruction_id_mktya:
10251 return pvm_recognize_specialized_instruction_mktya (ins->parameters, fl);
10252 case pvm_meta_instruction_id_mktyany:
10253 return pvm_recognize_specialized_instruction_mktyany (ins->parameters, fl);
10254 case pvm_meta_instruction_id_mktyc:
10255 return pvm_recognize_specialized_instruction_mktyc (ins->parameters, fl);
10256 case pvm_meta_instruction_id_mktyi:
10257 return pvm_recognize_specialized_instruction_mktyi (ins->parameters, fl);
10258 case pvm_meta_instruction_id_mktyo:
10259 return pvm_recognize_specialized_instruction_mktyo (ins->parameters, fl);
10260 case pvm_meta_instruction_id_mktys:
10261 return pvm_recognize_specialized_instruction_mktys (ins->parameters, fl);
10262 case pvm_meta_instruction_id_mktysct:
10263 return pvm_recognize_specialized_instruction_mktysct (ins->parameters, fl);
10264 case pvm_meta_instruction_id_mktyv:
10265 return pvm_recognize_specialized_instruction_mktyv (ins->parameters, fl);
10266 case pvm_meta_instruction_id_mm:
10267 return pvm_recognize_specialized_instruction_mm (ins->parameters, fl);
10268 case pvm_meta_instruction_id_modi:
10269 return pvm_recognize_specialized_instruction_modi (ins->parameters, fl);
10270 case pvm_meta_instruction_id_modiu:
10271 return pvm_recognize_specialized_instruction_modiu (ins->parameters, fl);
10272 case pvm_meta_instruction_id_modl:
10273 return pvm_recognize_specialized_instruction_modl (ins->parameters, fl);
10274 case pvm_meta_instruction_id_modlu:
10275 return pvm_recognize_specialized_instruction_modlu (ins->parameters, fl);
10276 case pvm_meta_instruction_id_msetios:
10277 return pvm_recognize_specialized_instruction_msetios (ins->parameters, fl);
10278 case pvm_meta_instruction_id_msetm:
10279 return pvm_recognize_specialized_instruction_msetm (ins->parameters, fl);
10280 case pvm_meta_instruction_id_mseto:
10281 return pvm_recognize_specialized_instruction_mseto (ins->parameters, fl);
10282 case pvm_meta_instruction_id_msets:
10283 return pvm_recognize_specialized_instruction_msets (ins->parameters, fl);
10284 case pvm_meta_instruction_id_msetsel:
10285 return pvm_recognize_specialized_instruction_msetsel (ins->parameters, fl);
10286 case pvm_meta_instruction_id_msetsiz:
10287 return pvm_recognize_specialized_instruction_msetsiz (ins->parameters, fl);
10288 case pvm_meta_instruction_id_msetw:
10289 return pvm_recognize_specialized_instruction_msetw (ins->parameters, fl);
10290 case pvm_meta_instruction_id_muli:
10291 return pvm_recognize_specialized_instruction_muli (ins->parameters, fl);
10292 case pvm_meta_instruction_id_muliu:
10293 return pvm_recognize_specialized_instruction_muliu (ins->parameters, fl);
10294 case pvm_meta_instruction_id_mull:
10295 return pvm_recognize_specialized_instruction_mull (ins->parameters, fl);
10296 case pvm_meta_instruction_id_mullu:
10297 return pvm_recognize_specialized_instruction_mullu (ins->parameters, fl);
10298 case pvm_meta_instruction_id_muls:
10299 return pvm_recognize_specialized_instruction_muls (ins->parameters, fl);
10300 case pvm_meta_instruction_id_negi:
10301 return pvm_recognize_specialized_instruction_negi (ins->parameters, fl);
10302 case pvm_meta_instruction_id_negiu:
10303 return pvm_recognize_specialized_instruction_negiu (ins->parameters, fl);
10304 case pvm_meta_instruction_id_negl:
10305 return pvm_recognize_specialized_instruction_negl (ins->parameters, fl);
10306 case pvm_meta_instruction_id_neglu:
10307 return pvm_recognize_specialized_instruction_neglu (ins->parameters, fl);
10308 case pvm_meta_instruction_id_nei:
10309 return pvm_recognize_specialized_instruction_nei (ins->parameters, fl);
10310 case pvm_meta_instruction_id_neiu:
10311 return pvm_recognize_specialized_instruction_neiu (ins->parameters, fl);
10312 case pvm_meta_instruction_id_nel:
10313 return pvm_recognize_specialized_instruction_nel (ins->parameters, fl);
10314 case pvm_meta_instruction_id_nelu:
10315 return pvm_recognize_specialized_instruction_nelu (ins->parameters, fl);
10316 case pvm_meta_instruction_id_nes:
10317 return pvm_recognize_specialized_instruction_nes (ins->parameters, fl);
10318 case pvm_meta_instruction_id_nip:
10319 return pvm_recognize_specialized_instruction_nip (ins->parameters, fl);
10320 case pvm_meta_instruction_id_nip2:
10321 return pvm_recognize_specialized_instruction_nip2 (ins->parameters, fl);
10322 case pvm_meta_instruction_id_nip3:
10323 return pvm_recognize_specialized_instruction_nip3 (ins->parameters, fl);
10324 case pvm_meta_instruction_id_nn:
10325 return pvm_recognize_specialized_instruction_nn (ins->parameters, fl);
10326 case pvm_meta_instruction_id_nnn:
10327 return pvm_recognize_specialized_instruction_nnn (ins->parameters, fl);
10328 case pvm_meta_instruction_id_nop:
10329 return pvm_recognize_specialized_instruction_nop (ins->parameters, fl);
10330 case pvm_meta_instruction_id_not:
10331 return pvm_recognize_specialized_instruction_not (ins->parameters, fl);
10332 case pvm_meta_instruction_id_note:
10333 return pvm_recognize_specialized_instruction_note (ins->parameters, fl);
10334 case pvm_meta_instruction_id_nrot:
10335 return pvm_recognize_specialized_instruction_nrot (ins->parameters, fl);
10336 case pvm_meta_instruction_id_ogetbt:
10337 return pvm_recognize_specialized_instruction_ogetbt (ins->parameters, fl);
10338 case pvm_meta_instruction_id_ogetm:
10339 return pvm_recognize_specialized_instruction_ogetm (ins->parameters, fl);
10340 case pvm_meta_instruction_id_ogetu:
10341 return pvm_recognize_specialized_instruction_ogetu (ins->parameters, fl);
10342 case pvm_meta_instruction_id_open:
10343 return pvm_recognize_specialized_instruction_open (ins->parameters, fl);
10344 case pvm_meta_instruction_id_or:
10345 return pvm_recognize_specialized_instruction_or (ins->parameters, fl);
10346 case pvm_meta_instruction_id_osetm:
10347 return pvm_recognize_specialized_instruction_osetm (ins->parameters, fl);
10348 case pvm_meta_instruction_id_over:
10349 return pvm_recognize_specialized_instruction_over (ins->parameters, fl);
10350 case pvm_meta_instruction_id_pec:
10351 return pvm_recognize_specialized_instruction_pec (ins->parameters, fl);
10352 case pvm_meta_instruction_id_peekdi:
10353 return pvm_recognize_specialized_instruction_peekdi (ins->parameters, fl);
10354 case pvm_meta_instruction_id_peekdiu:
10355 return pvm_recognize_specialized_instruction_peekdiu (ins->parameters, fl);
10356 case pvm_meta_instruction_id_peekdl:
10357 return pvm_recognize_specialized_instruction_peekdl (ins->parameters, fl);
10358 case pvm_meta_instruction_id_peekdlu:
10359 return pvm_recognize_specialized_instruction_peekdlu (ins->parameters, fl);
10360 case pvm_meta_instruction_id_peeki:
10361 return pvm_recognize_specialized_instruction_peeki (ins->parameters, fl);
10362 case pvm_meta_instruction_id_peekiu:
10363 return pvm_recognize_specialized_instruction_peekiu (ins->parameters, fl);
10364 case pvm_meta_instruction_id_peekl:
10365 return pvm_recognize_specialized_instruction_peekl (ins->parameters, fl);
10366 case pvm_meta_instruction_id_peeklu:
10367 return pvm_recognize_specialized_instruction_peeklu (ins->parameters, fl);
10368 case pvm_meta_instruction_id_peeks:
10369 return pvm_recognize_specialized_instruction_peeks (ins->parameters, fl);
10370 case pvm_meta_instruction_id_pokedi:
10371 return pvm_recognize_specialized_instruction_pokedi (ins->parameters, fl);
10372 case pvm_meta_instruction_id_pokediu:
10373 return pvm_recognize_specialized_instruction_pokediu (ins->parameters, fl);
10374 case pvm_meta_instruction_id_pokedl:
10375 return pvm_recognize_specialized_instruction_pokedl (ins->parameters, fl);
10376 case pvm_meta_instruction_id_pokedlu:
10377 return pvm_recognize_specialized_instruction_pokedlu (ins->parameters, fl);
10378 case pvm_meta_instruction_id_pokei:
10379 return pvm_recognize_specialized_instruction_pokei (ins->parameters, fl);
10380 case pvm_meta_instruction_id_pokeiu:
10381 return pvm_recognize_specialized_instruction_pokeiu (ins->parameters, fl);
10382 case pvm_meta_instruction_id_pokel:
10383 return pvm_recognize_specialized_instruction_pokel (ins->parameters, fl);
10384 case pvm_meta_instruction_id_pokelu:
10385 return pvm_recognize_specialized_instruction_pokelu (ins->parameters, fl);
10386 case pvm_meta_instruction_id_pokes:
10387 return pvm_recognize_specialized_instruction_pokes (ins->parameters, fl);
10388 case pvm_meta_instruction_id_pope:
10389 return pvm_recognize_specialized_instruction_pope (ins->parameters, fl);
10390 case pvm_meta_instruction_id_popend:
10391 return pvm_recognize_specialized_instruction_popend (ins->parameters, fl);
10392 case pvm_meta_instruction_id_popf:
10393 return pvm_recognize_specialized_instruction_popf (ins->parameters, fl);
10394 case pvm_meta_instruction_id_popios:
10395 return pvm_recognize_specialized_instruction_popios (ins->parameters, fl);
10396 case pvm_meta_instruction_id_popoac:
10397 return pvm_recognize_specialized_instruction_popoac (ins->parameters, fl);
10398 case pvm_meta_instruction_id_popob:
10399 return pvm_recognize_specialized_instruction_popob (ins->parameters, fl);
10400 case pvm_meta_instruction_id_popobc:
10401 return pvm_recognize_specialized_instruction_popobc (ins->parameters, fl);
10402 case pvm_meta_instruction_id_popoc:
10403 return pvm_recognize_specialized_instruction_popoc (ins->parameters, fl);
10404 case pvm_meta_instruction_id_popod:
10405 return pvm_recognize_specialized_instruction_popod (ins->parameters, fl);
10406 case pvm_meta_instruction_id_popoi:
10407 return pvm_recognize_specialized_instruction_popoi (ins->parameters, fl);
10408 case pvm_meta_instruction_id_popom:
10409 return pvm_recognize_specialized_instruction_popom (ins->parameters, fl);
10410 case pvm_meta_instruction_id_popoo:
10411 return pvm_recognize_specialized_instruction_popoo (ins->parameters, fl);
10412 case pvm_meta_instruction_id_popopp:
10413 return pvm_recognize_specialized_instruction_popopp (ins->parameters, fl);
10414 case pvm_meta_instruction_id_popr:
10415 return pvm_recognize_specialized_instruction_popr (ins->parameters, fl);
10416 case pvm_meta_instruction_id_popvar:
10417 return pvm_recognize_specialized_instruction_popvar (ins->parameters, fl);
10418 case pvm_meta_instruction_id_powi:
10419 return pvm_recognize_specialized_instruction_powi (ins->parameters, fl);
10420 case pvm_meta_instruction_id_powiu:
10421 return pvm_recognize_specialized_instruction_powiu (ins->parameters, fl);
10422 case pvm_meta_instruction_id_powl:
10423 return pvm_recognize_specialized_instruction_powl (ins->parameters, fl);
10424 case pvm_meta_instruction_id_powlu:
10425 return pvm_recognize_specialized_instruction_powlu (ins->parameters, fl);
10426 case pvm_meta_instruction_id_printi:
10427 return pvm_recognize_specialized_instruction_printi (ins->parameters, fl);
10428 case pvm_meta_instruction_id_printiu:
10429 return pvm_recognize_specialized_instruction_printiu (ins->parameters, fl);
10430 case pvm_meta_instruction_id_printl:
10431 return pvm_recognize_specialized_instruction_printl (ins->parameters, fl);
10432 case pvm_meta_instruction_id_printlu:
10433 return pvm_recognize_specialized_instruction_printlu (ins->parameters, fl);
10434 case pvm_meta_instruction_id_prints:
10435 return pvm_recognize_specialized_instruction_prints (ins->parameters, fl);
10436 case pvm_meta_instruction_id_prolog:
10437 return pvm_recognize_specialized_instruction_prolog (ins->parameters, fl);
10438 case pvm_meta_instruction_id_push:
10439 return pvm_recognize_specialized_instruction_push (ins->parameters, fl);
10440 case pvm_meta_instruction_id_push32:
10441 return pvm_recognize_specialized_instruction_push32 (ins->parameters, fl);
10442 case pvm_meta_instruction_id_pushe:
10443 return pvm_recognize_specialized_instruction_pushe (ins->parameters, fl);
10444 case pvm_meta_instruction_id_pushend:
10445 return pvm_recognize_specialized_instruction_pushend (ins->parameters, fl);
10446 case pvm_meta_instruction_id_pushf:
10447 return pvm_recognize_specialized_instruction_pushf (ins->parameters, fl);
10448 case pvm_meta_instruction_id_pushhi:
10449 return pvm_recognize_specialized_instruction_pushhi (ins->parameters, fl);
10450 case pvm_meta_instruction_id_pushios:
10451 return pvm_recognize_specialized_instruction_pushios (ins->parameters, fl);
10452 case pvm_meta_instruction_id_pushlo:
10453 return pvm_recognize_specialized_instruction_pushlo (ins->parameters, fl);
10454 case pvm_meta_instruction_id_pushoac:
10455 return pvm_recognize_specialized_instruction_pushoac (ins->parameters, fl);
10456 case pvm_meta_instruction_id_pushob:
10457 return pvm_recognize_specialized_instruction_pushob (ins->parameters, fl);
10458 case pvm_meta_instruction_id_pushobc:
10459 return pvm_recognize_specialized_instruction_pushobc (ins->parameters, fl);
10460 case pvm_meta_instruction_id_pushoc:
10461 return pvm_recognize_specialized_instruction_pushoc (ins->parameters, fl);
10462 case pvm_meta_instruction_id_pushod:
10463 return pvm_recognize_specialized_instruction_pushod (ins->parameters, fl);
10464 case pvm_meta_instruction_id_pushoi:
10465 return pvm_recognize_specialized_instruction_pushoi (ins->parameters, fl);
10466 case pvm_meta_instruction_id_pushom:
10467 return pvm_recognize_specialized_instruction_pushom (ins->parameters, fl);
10468 case pvm_meta_instruction_id_pushoo:
10469 return pvm_recognize_specialized_instruction_pushoo (ins->parameters, fl);
10470 case pvm_meta_instruction_id_pushopp:
10471 return pvm_recognize_specialized_instruction_pushopp (ins->parameters, fl);
10472 case pvm_meta_instruction_id_pushr:
10473 return pvm_recognize_specialized_instruction_pushr (ins->parameters, fl);
10474 case pvm_meta_instruction_id_pushtopvar:
10475 return pvm_recognize_specialized_instruction_pushtopvar (ins->parameters, fl);
10476 case pvm_meta_instruction_id_pushvar:
10477 return pvm_recognize_specialized_instruction_pushvar (ins->parameters, fl);
10478 case pvm_meta_instruction_id_quake:
10479 return pvm_recognize_specialized_instruction_quake (ins->parameters, fl);
10480 case pvm_meta_instruction_id_raise:
10481 return pvm_recognize_specialized_instruction_raise (ins->parameters, fl);
10482 case pvm_meta_instruction_id_rand:
10483 return pvm_recognize_specialized_instruction_rand (ins->parameters, fl);
10484 case pvm_meta_instruction_id_regvar:
10485 return pvm_recognize_specialized_instruction_regvar (ins->parameters, fl);
10486 case pvm_meta_instruction_id_reloc:
10487 return pvm_recognize_specialized_instruction_reloc (ins->parameters, fl);
10488 case pvm_meta_instruction_id_restorer:
10489 return pvm_recognize_specialized_instruction_restorer (ins->parameters, fl);
10490 case pvm_meta_instruction_id_return:
10491 return pvm_recognize_specialized_instruction_return (ins->parameters, fl);
10492 case pvm_meta_instruction_id_revn:
10493 return pvm_recognize_specialized_instruction_revn (ins->parameters, fl);
10494 case pvm_meta_instruction_id_rot:
10495 return pvm_recognize_specialized_instruction_rot (ins->parameters, fl);
10496 case pvm_meta_instruction_id_saver:
10497 return pvm_recognize_specialized_instruction_saver (ins->parameters, fl);
10498 case pvm_meta_instruction_id_sconc:
10499 return pvm_recognize_specialized_instruction_sconc (ins->parameters, fl);
10500 case pvm_meta_instruction_id_sel:
10501 return pvm_recognize_specialized_instruction_sel (ins->parameters, fl);
10502 case pvm_meta_instruction_id_setr:
10503 return pvm_recognize_specialized_instruction_setr (ins->parameters, fl);
10504 case pvm_meta_instruction_id_siz:
10505 return pvm_recognize_specialized_instruction_siz (ins->parameters, fl);
10506 case pvm_meta_instruction_id_smodi:
10507 return pvm_recognize_specialized_instruction_smodi (ins->parameters, fl);
10508 case pvm_meta_instruction_id_sref:
10509 return pvm_recognize_specialized_instruction_sref (ins->parameters, fl);
10510 case pvm_meta_instruction_id_srefi:
10511 return pvm_recognize_specialized_instruction_srefi (ins->parameters, fl);
10512 case pvm_meta_instruction_id_srefia:
10513 return pvm_recognize_specialized_instruction_srefia (ins->parameters, fl);
10514 case pvm_meta_instruction_id_srefio:
10515 return pvm_recognize_specialized_instruction_srefio (ins->parameters, fl);
10516 case pvm_meta_instruction_id_srefmnt:
10517 return pvm_recognize_specialized_instruction_srefmnt (ins->parameters, fl);
10518 case pvm_meta_instruction_id_srefnt:
10519 return pvm_recognize_specialized_instruction_srefnt (ins->parameters, fl);
10520 case pvm_meta_instruction_id_srefo:
10521 return pvm_recognize_specialized_instruction_srefo (ins->parameters, fl);
10522 case pvm_meta_instruction_id_sset:
10523 return pvm_recognize_specialized_instruction_sset (ins->parameters, fl);
10524 case pvm_meta_instruction_id_strace:
10525 return pvm_recognize_specialized_instruction_strace (ins->parameters, fl);
10526 case pvm_meta_instruction_id_strref:
10527 return pvm_recognize_specialized_instruction_strref (ins->parameters, fl);
10528 case pvm_meta_instruction_id_subi:
10529 return pvm_recognize_specialized_instruction_subi (ins->parameters, fl);
10530 case pvm_meta_instruction_id_subiu:
10531 return pvm_recognize_specialized_instruction_subiu (ins->parameters, fl);
10532 case pvm_meta_instruction_id_subl:
10533 return pvm_recognize_specialized_instruction_subl (ins->parameters, fl);
10534 case pvm_meta_instruction_id_sublu:
10535 return pvm_recognize_specialized_instruction_sublu (ins->parameters, fl);
10536 case pvm_meta_instruction_id_substr:
10537 return pvm_recognize_specialized_instruction_substr (ins->parameters, fl);
10538 case pvm_meta_instruction_id_swap:
10539 return pvm_recognize_specialized_instruction_swap (ins->parameters, fl);
10540 case pvm_meta_instruction_id_swapgti:
10541 return pvm_recognize_specialized_instruction_swapgti (ins->parameters, fl);
10542 case pvm_meta_instruction_id_swapgtiu:
10543 return pvm_recognize_specialized_instruction_swapgtiu (ins->parameters, fl);
10544 case pvm_meta_instruction_id_swapgtl:
10545 return pvm_recognize_specialized_instruction_swapgtl (ins->parameters, fl);
10546 case pvm_meta_instruction_id_swapgtlu:
10547 return pvm_recognize_specialized_instruction_swapgtlu (ins->parameters, fl);
10548 case pvm_meta_instruction_id_sync:
10549 return pvm_recognize_specialized_instruction_sync (ins->parameters, fl);
10550 case pvm_meta_instruction_id_time:
10551 return pvm_recognize_specialized_instruction_time (ins->parameters, fl);
10552 case pvm_meta_instruction_id_tor:
10553 return pvm_recognize_specialized_instruction_tor (ins->parameters, fl);
10554 case pvm_meta_instruction_id_tuck:
10555 return pvm_recognize_specialized_instruction_tuck (ins->parameters, fl);
10556 case pvm_meta_instruction_id_tyagetb:
10557 return pvm_recognize_specialized_instruction_tyagetb (ins->parameters, fl);
10558 case pvm_meta_instruction_id_tyagett:
10559 return pvm_recognize_specialized_instruction_tyagett (ins->parameters, fl);
10560 case pvm_meta_instruction_id_tyisc:
10561 return pvm_recognize_specialized_instruction_tyisc (ins->parameters, fl);
10562 case pvm_meta_instruction_id_tyissct:
10563 return pvm_recognize_specialized_instruction_tyissct (ins->parameters, fl);
10564 case pvm_meta_instruction_id_typof:
10565 return pvm_recognize_specialized_instruction_typof (ins->parameters, fl);
10566 case pvm_meta_instruction_id_tysctn:
10567 return pvm_recognize_specialized_instruction_tysctn (ins->parameters, fl);
10568 case pvm_meta_instruction_id_unmap:
10569 return pvm_recognize_specialized_instruction_unmap (ins->parameters, fl);
10570 case pvm_meta_instruction_id_unreachable:
10571 return pvm_recognize_specialized_instruction_unreachable (ins->parameters, fl);
10572 case pvm_meta_instruction_id_ureloc:
10573 return pvm_recognize_specialized_instruction_ureloc (ins->parameters, fl);
10574 case pvm_meta_instruction_id_write:
10575 return pvm_recognize_specialized_instruction_write (ins->parameters, fl);
10576 default:
10577 jitter_fatal ("invalid meta-instruction id %i", (int)mi->id);
10578 }
10579 __builtin_unreachable ();
10580 }
10581
10582 /* Specializer entry point: the only non-static function here. */
10583 int
pvm_specialize_instruction(struct jitter_mutable_routine * p,const struct jitter_instruction * ins)10584 pvm_specialize_instruction (struct jitter_mutable_routine *p,
10585 const struct jitter_instruction *ins)
10586 {
10587 enum pvm_specialized_instruction_opcode opcode
10588 = pvm_recognize_specialized_instruction (p, ins);
10589 if (opcode == pvm_specialized_instruction_opcode__eINVALID)
10590 jitter_fatal ("specialization failed: %s", ins->meta_instruction->name);
10591
10592 #ifdef JITTER_HAVE_PATCH_IN
10593 /* Replace the opcode with its non-defective counterpart. */
10594 opcode = pvm_defect_table [opcode];
10595 #endif // #ifdef JITTER_HAVE_PATCH_IN
10596
10597 jitter_add_specialized_instruction_opcode (p, opcode);
10598
10599
10600 /* FIXME: in the old shell-based generator I grouped specialized instructions by
10601 their "residual parameter map", yielding a switch with a lot of different
10602 specialized instructions mapping to the same case. I should redo that here. */
10603 switch (opcode)
10604 {
10605 case pvm_specialized_instruction_opcode__eINVALID:
10606 break;
10607
10608 case pvm_specialized_instruction_opcode__eBEGINBASICBLOCK:
10609 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
10610 break;
10611
10612 case pvm_specialized_instruction_opcode__eEXITVM:
10613 break;
10614
10615 case pvm_specialized_instruction_opcode__eDATALOCATIONS:
10616 break;
10617
10618 case pvm_specialized_instruction_opcode__eNOP:
10619 break;
10620
10621 case pvm_specialized_instruction_opcode__eUNREACHABLE0:
10622 break;
10623
10624 case pvm_specialized_instruction_opcode__eUNREACHABLE1:
10625 break;
10626
10627 case pvm_specialized_instruction_opcode__eUNREACHABLE2:
10628 break;
10629
10630 case pvm_specialized_instruction_opcode_addi:
10631 break;
10632
10633 case pvm_specialized_instruction_opcode_addiu:
10634 break;
10635
10636 case pvm_specialized_instruction_opcode_addl:
10637 break;
10638
10639 case pvm_specialized_instruction_opcode_addlu:
10640 break;
10641
10642 case pvm_specialized_instruction_opcode_ains:
10643 break;
10644
10645 case pvm_specialized_instruction_opcode_and:
10646 break;
10647
10648 case pvm_specialized_instruction_opcode_aref:
10649 break;
10650
10651 case pvm_specialized_instruction_opcode_arefo:
10652 break;
10653
10654 case pvm_specialized_instruction_opcode_arem:
10655 break;
10656
10657 case pvm_specialized_instruction_opcode_aset:
10658 break;
10659
10660 case pvm_specialized_instruction_opcode_asettb:
10661 break;
10662
10663 case pvm_specialized_instruction_opcode_atr:
10664 break;
10665
10666 case pvm_specialized_instruction_opcode_ba__fR:
10667 jitter_add_specialized_instruction_label_index (p, ins->parameters[0]->label_as_index);
10668 break;
10669
10670 case pvm_specialized_instruction_opcode_bandi:
10671 break;
10672
10673 case pvm_specialized_instruction_opcode_bandiu:
10674 break;
10675
10676 case pvm_specialized_instruction_opcode_bandl:
10677 break;
10678
10679 case pvm_specialized_instruction_opcode_bandlu:
10680 break;
10681
10682 case pvm_specialized_instruction_opcode_beghl:
10683 break;
10684
10685 case pvm_specialized_instruction_opcode_begsc:
10686 break;
10687
10688 case pvm_specialized_instruction_opcode_bn__fR:
10689 jitter_add_specialized_instruction_label_index (p, ins->parameters[0]->label_as_index);
10690 break;
10691
10692 case pvm_specialized_instruction_opcode_bnn__fR:
10693 jitter_add_specialized_instruction_label_index (p, ins->parameters[0]->label_as_index);
10694 break;
10695
10696 case pvm_specialized_instruction_opcode_bnoti:
10697 break;
10698
10699 case pvm_specialized_instruction_opcode_bnotiu:
10700 break;
10701
10702 case pvm_specialized_instruction_opcode_bnotl:
10703 break;
10704
10705 case pvm_specialized_instruction_opcode_bnotlu:
10706 break;
10707
10708 case pvm_specialized_instruction_opcode_bnzi__fR:
10709 jitter_add_specialized_instruction_label_index (p, ins->parameters[0]->label_as_index);
10710 break;
10711
10712 case pvm_specialized_instruction_opcode_bnziu__fR:
10713 jitter_add_specialized_instruction_label_index (p, ins->parameters[0]->label_as_index);
10714 break;
10715
10716 case pvm_specialized_instruction_opcode_bnzl__fR:
10717 jitter_add_specialized_instruction_label_index (p, ins->parameters[0]->label_as_index);
10718 break;
10719
10720 case pvm_specialized_instruction_opcode_bnzlu__fR:
10721 jitter_add_specialized_instruction_label_index (p, ins->parameters[0]->label_as_index);
10722 break;
10723
10724 case pvm_specialized_instruction_opcode_bori:
10725 break;
10726
10727 case pvm_specialized_instruction_opcode_boriu:
10728 break;
10729
10730 case pvm_specialized_instruction_opcode_borl:
10731 break;
10732
10733 case pvm_specialized_instruction_opcode_borlu:
10734 break;
10735
10736 case pvm_specialized_instruction_opcode_bsli:
10737 break;
10738
10739 case pvm_specialized_instruction_opcode_bsliu:
10740 break;
10741
10742 case pvm_specialized_instruction_opcode_bsll:
10743 break;
10744
10745 case pvm_specialized_instruction_opcode_bsllu:
10746 break;
10747
10748 case pvm_specialized_instruction_opcode_bsri:
10749 break;
10750
10751 case pvm_specialized_instruction_opcode_bsriu:
10752 break;
10753
10754 case pvm_specialized_instruction_opcode_bsrl:
10755 break;
10756
10757 case pvm_specialized_instruction_opcode_bsrlu:
10758 break;
10759
10760 case pvm_specialized_instruction_opcode_bxori:
10761 break;
10762
10763 case pvm_specialized_instruction_opcode_bxoriu:
10764 break;
10765
10766 case pvm_specialized_instruction_opcode_bxorl:
10767 break;
10768
10769 case pvm_specialized_instruction_opcode_bxorlu:
10770 break;
10771
10772 case pvm_specialized_instruction_opcode_bzi__fR:
10773 jitter_add_specialized_instruction_label_index (p, ins->parameters[0]->label_as_index);
10774 break;
10775
10776 case pvm_specialized_instruction_opcode_bziu__fR:
10777 jitter_add_specialized_instruction_label_index (p, ins->parameters[0]->label_as_index);
10778 break;
10779
10780 case pvm_specialized_instruction_opcode_bzl__fR:
10781 jitter_add_specialized_instruction_label_index (p, ins->parameters[0]->label_as_index);
10782 break;
10783
10784 case pvm_specialized_instruction_opcode_bzlu__fR:
10785 jitter_add_specialized_instruction_label_index (p, ins->parameters[0]->label_as_index);
10786 break;
10787
10788 case pvm_specialized_instruction_opcode_call__retR:
10789 /* Caller instruction: make place for the return address,
10790 whose correct value will be patched in at specialization time. */
10791 jitter_add_specialized_instruction_literal (p, -1);
10792 break;
10793
10794 case pvm_specialized_instruction_opcode_canary:
10795 break;
10796
10797 case pvm_specialized_instruction_opcode_close:
10798 break;
10799
10800 case pvm_specialized_instruction_opcode_ctos:
10801 break;
10802
10803 case pvm_specialized_instruction_opcode_disas:
10804 break;
10805
10806 case pvm_specialized_instruction_opcode_divi:
10807 break;
10808
10809 case pvm_specialized_instruction_opcode_diviu:
10810 break;
10811
10812 case pvm_specialized_instruction_opcode_divl:
10813 break;
10814
10815 case pvm_specialized_instruction_opcode_divlu:
10816 break;
10817
10818 case pvm_specialized_instruction_opcode_drop:
10819 break;
10820
10821 case pvm_specialized_instruction_opcode_drop2:
10822 break;
10823
10824 case pvm_specialized_instruction_opcode_drop3:
10825 break;
10826
10827 case pvm_specialized_instruction_opcode_drop4:
10828 break;
10829
10830 case pvm_specialized_instruction_opcode_duc:
10831 break;
10832
10833 case pvm_specialized_instruction_opcode_dup:
10834 break;
10835
10836 case pvm_specialized_instruction_opcode_endhl:
10837 break;
10838
10839 case pvm_specialized_instruction_opcode_endsc:
10840 break;
10841
10842 case pvm_specialized_instruction_opcode_eqi:
10843 break;
10844
10845 case pvm_specialized_instruction_opcode_eqiu:
10846 break;
10847
10848 case pvm_specialized_instruction_opcode_eql:
10849 break;
10850
10851 case pvm_specialized_instruction_opcode_eqlu:
10852 break;
10853
10854 case pvm_specialized_instruction_opcode_eqs:
10855 break;
10856
10857 case pvm_specialized_instruction_opcode_exit:
10858 break;
10859
10860 case pvm_specialized_instruction_opcode_exitvm:
10861 break;
10862
10863 case pvm_specialized_instruction_opcode_flush:
10864 break;
10865
10866 case pvm_specialized_instruction_opcode_fromr:
10867 break;
10868
10869 case pvm_specialized_instruction_opcode_gei:
10870 break;
10871
10872 case pvm_specialized_instruction_opcode_geiu:
10873 break;
10874
10875 case pvm_specialized_instruction_opcode_gel:
10876 break;
10877
10878 case pvm_specialized_instruction_opcode_gelu:
10879 break;
10880
10881 case pvm_specialized_instruction_opcode_ges:
10882 break;
10883
10884 case pvm_specialized_instruction_opcode_getenv:
10885 break;
10886
10887 case pvm_specialized_instruction_opcode_gti:
10888 break;
10889
10890 case pvm_specialized_instruction_opcode_gtiu:
10891 break;
10892
10893 case pvm_specialized_instruction_opcode_gtl:
10894 break;
10895
10896 case pvm_specialized_instruction_opcode_gtlu:
10897 break;
10898
10899 case pvm_specialized_instruction_opcode_gts:
10900 break;
10901
10902 case pvm_specialized_instruction_opcode_indent:
10903 break;
10904
10905 case pvm_specialized_instruction_opcode_iogetb:
10906 break;
10907
10908 case pvm_specialized_instruction_opcode_iosetb:
10909 break;
10910
10911 case pvm_specialized_instruction_opcode_iosize:
10912 break;
10913
10914 case pvm_specialized_instruction_opcode_isa:
10915 break;
10916
10917 case pvm_specialized_instruction_opcode_itoi__nR:
10918 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
10919 break;
10920
10921 case pvm_specialized_instruction_opcode_itoiu__nR:
10922 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
10923 break;
10924
10925 case pvm_specialized_instruction_opcode_itol__nR:
10926 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
10927 break;
10928
10929 case pvm_specialized_instruction_opcode_itolu__nR:
10930 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
10931 break;
10932
10933 case pvm_specialized_instruction_opcode_iutoi__nR:
10934 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
10935 break;
10936
10937 case pvm_specialized_instruction_opcode_iutoiu__nR:
10938 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
10939 break;
10940
10941 case pvm_specialized_instruction_opcode_iutol__nR:
10942 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
10943 break;
10944
10945 case pvm_specialized_instruction_opcode_iutolu__nR:
10946 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
10947 break;
10948
10949 case pvm_specialized_instruction_opcode_lei:
10950 break;
10951
10952 case pvm_specialized_instruction_opcode_leiu:
10953 break;
10954
10955 case pvm_specialized_instruction_opcode_lel:
10956 break;
10957
10958 case pvm_specialized_instruction_opcode_lelu:
10959 break;
10960
10961 case pvm_specialized_instruction_opcode_les:
10962 break;
10963
10964 case pvm_specialized_instruction_opcode_lti:
10965 break;
10966
10967 case pvm_specialized_instruction_opcode_ltiu:
10968 break;
10969
10970 case pvm_specialized_instruction_opcode_ltl:
10971 break;
10972
10973 case pvm_specialized_instruction_opcode_ltlu:
10974 break;
10975
10976 case pvm_specialized_instruction_opcode_ltoi__nR:
10977 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
10978 break;
10979
10980 case pvm_specialized_instruction_opcode_ltoiu__nR:
10981 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
10982 break;
10983
10984 case pvm_specialized_instruction_opcode_ltol__nR:
10985 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
10986 break;
10987
10988 case pvm_specialized_instruction_opcode_ltolu__nR:
10989 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
10990 break;
10991
10992 case pvm_specialized_instruction_opcode_lts:
10993 break;
10994
10995 case pvm_specialized_instruction_opcode_lutoi__nR:
10996 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
10997 break;
10998
10999 case pvm_specialized_instruction_opcode_lutoiu__nR:
11000 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11001 break;
11002
11003 case pvm_specialized_instruction_opcode_lutol__nR:
11004 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11005 break;
11006
11007 case pvm_specialized_instruction_opcode_lutolu__nR:
11008 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11009 break;
11010
11011 case pvm_specialized_instruction_opcode_map:
11012 break;
11013
11014 case pvm_specialized_instruction_opcode_mgetios:
11015 break;
11016
11017 case pvm_specialized_instruction_opcode_mgetm:
11018 break;
11019
11020 case pvm_specialized_instruction_opcode_mgeto:
11021 break;
11022
11023 case pvm_specialized_instruction_opcode_mgets:
11024 break;
11025
11026 case pvm_specialized_instruction_opcode_mgetsel:
11027 break;
11028
11029 case pvm_specialized_instruction_opcode_mgetsiz:
11030 break;
11031
11032 case pvm_specialized_instruction_opcode_mgetw:
11033 break;
11034
11035 case pvm_specialized_instruction_opcode_mka:
11036 break;
11037
11038 case pvm_specialized_instruction_opcode_mko:
11039 break;
11040
11041 case pvm_specialized_instruction_opcode_mksct:
11042 break;
11043
11044 case pvm_specialized_instruction_opcode_mktya:
11045 break;
11046
11047 case pvm_specialized_instruction_opcode_mktyany:
11048 break;
11049
11050 case pvm_specialized_instruction_opcode_mktyc:
11051 break;
11052
11053 case pvm_specialized_instruction_opcode_mktyi:
11054 break;
11055
11056 case pvm_specialized_instruction_opcode_mktyo:
11057 break;
11058
11059 case pvm_specialized_instruction_opcode_mktys:
11060 break;
11061
11062 case pvm_specialized_instruction_opcode_mktysct:
11063 break;
11064
11065 case pvm_specialized_instruction_opcode_mktyv:
11066 break;
11067
11068 case pvm_specialized_instruction_opcode_mm:
11069 break;
11070
11071 case pvm_specialized_instruction_opcode_modi:
11072 break;
11073
11074 case pvm_specialized_instruction_opcode_modiu:
11075 break;
11076
11077 case pvm_specialized_instruction_opcode_modl:
11078 break;
11079
11080 case pvm_specialized_instruction_opcode_modlu:
11081 break;
11082
11083 case pvm_specialized_instruction_opcode_msetios:
11084 break;
11085
11086 case pvm_specialized_instruction_opcode_msetm:
11087 break;
11088
11089 case pvm_specialized_instruction_opcode_mseto:
11090 break;
11091
11092 case pvm_specialized_instruction_opcode_msets:
11093 break;
11094
11095 case pvm_specialized_instruction_opcode_msetsel:
11096 break;
11097
11098 case pvm_specialized_instruction_opcode_msetsiz:
11099 break;
11100
11101 case pvm_specialized_instruction_opcode_msetw:
11102 break;
11103
11104 case pvm_specialized_instruction_opcode_muli:
11105 break;
11106
11107 case pvm_specialized_instruction_opcode_muliu:
11108 break;
11109
11110 case pvm_specialized_instruction_opcode_mull:
11111 break;
11112
11113 case pvm_specialized_instruction_opcode_mullu:
11114 break;
11115
11116 case pvm_specialized_instruction_opcode_muls:
11117 break;
11118
11119 case pvm_specialized_instruction_opcode_negi:
11120 break;
11121
11122 case pvm_specialized_instruction_opcode_negiu:
11123 break;
11124
11125 case pvm_specialized_instruction_opcode_negl:
11126 break;
11127
11128 case pvm_specialized_instruction_opcode_neglu:
11129 break;
11130
11131 case pvm_specialized_instruction_opcode_nei:
11132 break;
11133
11134 case pvm_specialized_instruction_opcode_neiu:
11135 break;
11136
11137 case pvm_specialized_instruction_opcode_nel:
11138 break;
11139
11140 case pvm_specialized_instruction_opcode_nelu:
11141 break;
11142
11143 case pvm_specialized_instruction_opcode_nes:
11144 break;
11145
11146 case pvm_specialized_instruction_opcode_nip:
11147 break;
11148
11149 case pvm_specialized_instruction_opcode_nip2:
11150 break;
11151
11152 case pvm_specialized_instruction_opcode_nip3:
11153 break;
11154
11155 case pvm_specialized_instruction_opcode_nn:
11156 break;
11157
11158 case pvm_specialized_instruction_opcode_nnn:
11159 break;
11160
11161 case pvm_specialized_instruction_opcode_nop:
11162 break;
11163
11164 case pvm_specialized_instruction_opcode_not:
11165 break;
11166
11167 case pvm_specialized_instruction_opcode_note__nR:
11168 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11169 break;
11170
11171 case pvm_specialized_instruction_opcode_nrot:
11172 break;
11173
11174 case pvm_specialized_instruction_opcode_ogetbt:
11175 break;
11176
11177 case pvm_specialized_instruction_opcode_ogetm:
11178 break;
11179
11180 case pvm_specialized_instruction_opcode_ogetu:
11181 break;
11182
11183 case pvm_specialized_instruction_opcode_open:
11184 break;
11185
11186 case pvm_specialized_instruction_opcode_or:
11187 break;
11188
11189 case pvm_specialized_instruction_opcode_osetm:
11190 break;
11191
11192 case pvm_specialized_instruction_opcode_over:
11193 break;
11194
11195 case pvm_specialized_instruction_opcode_pec:
11196 break;
11197
11198 case pvm_specialized_instruction_opcode_peekdi__nR:
11199 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11200 break;
11201
11202 case pvm_specialized_instruction_opcode_peekdiu__nR:
11203 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11204 break;
11205
11206 case pvm_specialized_instruction_opcode_peekdl__nR:
11207 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11208 break;
11209
11210 case pvm_specialized_instruction_opcode_peekdlu__nR:
11211 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11212 break;
11213
11214 case pvm_specialized_instruction_opcode_peeki__nR__nR__nR:
11215 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11216 jitter_add_specialized_instruction_literal (p, ins->parameters[1]->literal.ufixnum);
11217 jitter_add_specialized_instruction_literal (p, ins->parameters[2]->literal.ufixnum);
11218 break;
11219
11220 case pvm_specialized_instruction_opcode_peekiu__nR__nR:
11221 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11222 jitter_add_specialized_instruction_literal (p, ins->parameters[1]->literal.ufixnum);
11223 break;
11224
11225 case pvm_specialized_instruction_opcode_peekl__nR__nR__nR:
11226 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11227 jitter_add_specialized_instruction_literal (p, ins->parameters[1]->literal.ufixnum);
11228 jitter_add_specialized_instruction_literal (p, ins->parameters[2]->literal.ufixnum);
11229 break;
11230
11231 case pvm_specialized_instruction_opcode_peeklu__nR__nR:
11232 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11233 jitter_add_specialized_instruction_literal (p, ins->parameters[1]->literal.ufixnum);
11234 break;
11235
11236 case pvm_specialized_instruction_opcode_peeks:
11237 break;
11238
11239 case pvm_specialized_instruction_opcode_pokedi__nR:
11240 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11241 break;
11242
11243 case pvm_specialized_instruction_opcode_pokediu__nR:
11244 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11245 break;
11246
11247 case pvm_specialized_instruction_opcode_pokedl__nR:
11248 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11249 break;
11250
11251 case pvm_specialized_instruction_opcode_pokedlu__nR:
11252 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11253 break;
11254
11255 case pvm_specialized_instruction_opcode_pokei__nR__nR__nR:
11256 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11257 jitter_add_specialized_instruction_literal (p, ins->parameters[1]->literal.ufixnum);
11258 jitter_add_specialized_instruction_literal (p, ins->parameters[2]->literal.ufixnum);
11259 break;
11260
11261 case pvm_specialized_instruction_opcode_pokeiu__nR__nR:
11262 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11263 jitter_add_specialized_instruction_literal (p, ins->parameters[1]->literal.ufixnum);
11264 break;
11265
11266 case pvm_specialized_instruction_opcode_pokel__nR__nR__nR:
11267 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11268 jitter_add_specialized_instruction_literal (p, ins->parameters[1]->literal.ufixnum);
11269 jitter_add_specialized_instruction_literal (p, ins->parameters[2]->literal.ufixnum);
11270 break;
11271
11272 case pvm_specialized_instruction_opcode_pokelu__nR__nR:
11273 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11274 jitter_add_specialized_instruction_literal (p, ins->parameters[1]->literal.ufixnum);
11275 break;
11276
11277 case pvm_specialized_instruction_opcode_pokes:
11278 break;
11279
11280 case pvm_specialized_instruction_opcode_pope:
11281 break;
11282
11283 case pvm_specialized_instruction_opcode_popend:
11284 break;
11285
11286 case pvm_specialized_instruction_opcode_popf__nR:
11287 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11288 break;
11289
11290 case pvm_specialized_instruction_opcode_popios:
11291 break;
11292
11293 case pvm_specialized_instruction_opcode_popoac:
11294 break;
11295
11296 case pvm_specialized_instruction_opcode_popob:
11297 break;
11298
11299 case pvm_specialized_instruction_opcode_popobc:
11300 break;
11301
11302 case pvm_specialized_instruction_opcode_popoc:
11303 break;
11304
11305 case pvm_specialized_instruction_opcode_popod:
11306 break;
11307
11308 case pvm_specialized_instruction_opcode_popoi:
11309 break;
11310
11311 case pvm_specialized_instruction_opcode_popom:
11312 break;
11313
11314 case pvm_specialized_instruction_opcode_popoo:
11315 break;
11316
11317 case pvm_specialized_instruction_opcode_popopp:
11318 break;
11319
11320 case pvm_specialized_instruction_opcode_popr___rrR:
11321 /* A slow register is passed as a residual literal offset. */ jitter_add_specialized_instruction_literal (p, PVM_SLOW_REGISTER_OFFSET(r, ins->parameters[0]->register_index));
11322 break;
11323
11324 case pvm_specialized_instruction_opcode_popvar__nR__nR:
11325 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11326 jitter_add_specialized_instruction_literal (p, ins->parameters[1]->literal.ufixnum);
11327 break;
11328
11329 case pvm_specialized_instruction_opcode_powi:
11330 break;
11331
11332 case pvm_specialized_instruction_opcode_powiu:
11333 break;
11334
11335 case pvm_specialized_instruction_opcode_powl:
11336 break;
11337
11338 case pvm_specialized_instruction_opcode_powlu:
11339 break;
11340
11341 case pvm_specialized_instruction_opcode_printi__nR:
11342 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11343 break;
11344
11345 case pvm_specialized_instruction_opcode_printiu__nR:
11346 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11347 break;
11348
11349 case pvm_specialized_instruction_opcode_printl__nR:
11350 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11351 break;
11352
11353 case pvm_specialized_instruction_opcode_printlu__nR:
11354 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11355 break;
11356
11357 case pvm_specialized_instruction_opcode_prints:
11358 break;
11359
11360 case pvm_specialized_instruction_opcode_prolog:
11361 break;
11362
11363 case pvm_specialized_instruction_opcode_push__nR:
11364 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11365 break;
11366
11367 case pvm_specialized_instruction_opcode_push__lR:
11368 jitter_add_specialized_instruction_label_index (p, ins->parameters[0]->label_as_index);
11369 break;
11370
11371 case pvm_specialized_instruction_opcode_push32__nR:
11372 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11373 break;
11374
11375 case pvm_specialized_instruction_opcode_push32__lR:
11376 jitter_add_specialized_instruction_label_index (p, ins->parameters[0]->label_as_index);
11377 break;
11378
11379 case pvm_specialized_instruction_opcode_pushe__lR:
11380 jitter_add_specialized_instruction_label_index (p, ins->parameters[0]->label_as_index);
11381 break;
11382
11383 case pvm_specialized_instruction_opcode_pushend:
11384 break;
11385
11386 case pvm_specialized_instruction_opcode_pushf__nR:
11387 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11388 break;
11389
11390 case pvm_specialized_instruction_opcode_pushhi__nR:
11391 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11392 break;
11393
11394 case pvm_specialized_instruction_opcode_pushhi__lR:
11395 jitter_add_specialized_instruction_label_index (p, ins->parameters[0]->label_as_index);
11396 break;
11397
11398 case pvm_specialized_instruction_opcode_pushios:
11399 break;
11400
11401 case pvm_specialized_instruction_opcode_pushlo__nR:
11402 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11403 break;
11404
11405 case pvm_specialized_instruction_opcode_pushlo__lR:
11406 jitter_add_specialized_instruction_label_index (p, ins->parameters[0]->label_as_index);
11407 break;
11408
11409 case pvm_specialized_instruction_opcode_pushoac:
11410 break;
11411
11412 case pvm_specialized_instruction_opcode_pushob:
11413 break;
11414
11415 case pvm_specialized_instruction_opcode_pushobc:
11416 break;
11417
11418 case pvm_specialized_instruction_opcode_pushoc:
11419 break;
11420
11421 case pvm_specialized_instruction_opcode_pushod:
11422 break;
11423
11424 case pvm_specialized_instruction_opcode_pushoi:
11425 break;
11426
11427 case pvm_specialized_instruction_opcode_pushom:
11428 break;
11429
11430 case pvm_specialized_instruction_opcode_pushoo:
11431 break;
11432
11433 case pvm_specialized_instruction_opcode_pushopp:
11434 break;
11435
11436 case pvm_specialized_instruction_opcode_pushr___rrR:
11437 /* A slow register is passed as a residual literal offset. */ jitter_add_specialized_instruction_literal (p, PVM_SLOW_REGISTER_OFFSET(r, ins->parameters[0]->register_index));
11438 break;
11439
11440 case pvm_specialized_instruction_opcode_pushtopvar__nR:
11441 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11442 break;
11443
11444 case pvm_specialized_instruction_opcode_pushvar__n0__n0:
11445 break;
11446
11447 case pvm_specialized_instruction_opcode_pushvar__n0__n1:
11448 break;
11449
11450 case pvm_specialized_instruction_opcode_pushvar__n0__n2:
11451 break;
11452
11453 case pvm_specialized_instruction_opcode_pushvar__n0__n3:
11454 break;
11455
11456 case pvm_specialized_instruction_opcode_pushvar__n0__n4:
11457 break;
11458
11459 case pvm_specialized_instruction_opcode_pushvar__n0__n5:
11460 break;
11461
11462 case pvm_specialized_instruction_opcode_pushvar__n0__nR:
11463 jitter_add_specialized_instruction_literal (p, ins->parameters[1]->literal.ufixnum);
11464 break;
11465
11466 case pvm_specialized_instruction_opcode_pushvar__nR__n0:
11467 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11468 break;
11469
11470 case pvm_specialized_instruction_opcode_pushvar__nR__n1:
11471 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11472 break;
11473
11474 case pvm_specialized_instruction_opcode_pushvar__nR__n2:
11475 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11476 break;
11477
11478 case pvm_specialized_instruction_opcode_pushvar__nR__n3:
11479 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11480 break;
11481
11482 case pvm_specialized_instruction_opcode_pushvar__nR__n4:
11483 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11484 break;
11485
11486 case pvm_specialized_instruction_opcode_pushvar__nR__n5:
11487 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11488 break;
11489
11490 case pvm_specialized_instruction_opcode_pushvar__nR__nR:
11491 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11492 jitter_add_specialized_instruction_literal (p, ins->parameters[1]->literal.ufixnum);
11493 break;
11494
11495 case pvm_specialized_instruction_opcode_quake:
11496 break;
11497
11498 case pvm_specialized_instruction_opcode_raise:
11499 break;
11500
11501 case pvm_specialized_instruction_opcode_rand:
11502 break;
11503
11504 case pvm_specialized_instruction_opcode_regvar:
11505 break;
11506
11507 case pvm_specialized_instruction_opcode_reloc:
11508 break;
11509
11510 case pvm_specialized_instruction_opcode_restorer___rrR:
11511 /* A slow register is passed as a residual literal offset. */ jitter_add_specialized_instruction_literal (p, PVM_SLOW_REGISTER_OFFSET(r, ins->parameters[0]->register_index));
11512 break;
11513
11514 case pvm_specialized_instruction_opcode_return:
11515 break;
11516
11517 case pvm_specialized_instruction_opcode_revn__n3:
11518 break;
11519
11520 case pvm_specialized_instruction_opcode_revn__n4:
11521 break;
11522
11523 case pvm_specialized_instruction_opcode_revn__nR:
11524 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11525 break;
11526
11527 case pvm_specialized_instruction_opcode_rot:
11528 break;
11529
11530 case pvm_specialized_instruction_opcode_saver___rrR:
11531 /* A slow register is passed as a residual literal offset. */ jitter_add_specialized_instruction_literal (p, PVM_SLOW_REGISTER_OFFSET(r, ins->parameters[0]->register_index));
11532 break;
11533
11534 case pvm_specialized_instruction_opcode_sconc:
11535 break;
11536
11537 case pvm_specialized_instruction_opcode_sel:
11538 break;
11539
11540 case pvm_specialized_instruction_opcode_setr___rrR:
11541 /* A slow register is passed as a residual literal offset. */ jitter_add_specialized_instruction_literal (p, PVM_SLOW_REGISTER_OFFSET(r, ins->parameters[0]->register_index));
11542 break;
11543
11544 case pvm_specialized_instruction_opcode_siz:
11545 break;
11546
11547 case pvm_specialized_instruction_opcode_smodi:
11548 break;
11549
11550 case pvm_specialized_instruction_opcode_sref:
11551 break;
11552
11553 case pvm_specialized_instruction_opcode_srefi:
11554 break;
11555
11556 case pvm_specialized_instruction_opcode_srefia:
11557 break;
11558
11559 case pvm_specialized_instruction_opcode_srefio:
11560 break;
11561
11562 case pvm_specialized_instruction_opcode_srefmnt:
11563 break;
11564
11565 case pvm_specialized_instruction_opcode_srefnt:
11566 break;
11567
11568 case pvm_specialized_instruction_opcode_srefo:
11569 break;
11570
11571 case pvm_specialized_instruction_opcode_sset:
11572 break;
11573
11574 case pvm_specialized_instruction_opcode_strace__nR:
11575 jitter_add_specialized_instruction_literal (p, ins->parameters[0]->literal.ufixnum);
11576 break;
11577
11578 case pvm_specialized_instruction_opcode_strref:
11579 break;
11580
11581 case pvm_specialized_instruction_opcode_subi:
11582 break;
11583
11584 case pvm_specialized_instruction_opcode_subiu:
11585 break;
11586
11587 case pvm_specialized_instruction_opcode_subl:
11588 break;
11589
11590 case pvm_specialized_instruction_opcode_sublu:
11591 break;
11592
11593 case pvm_specialized_instruction_opcode_substr:
11594 break;
11595
11596 case pvm_specialized_instruction_opcode_swap:
11597 break;
11598
11599 case pvm_specialized_instruction_opcode_swapgti:
11600 break;
11601
11602 case pvm_specialized_instruction_opcode_swapgtiu:
11603 break;
11604
11605 case pvm_specialized_instruction_opcode_swapgtl:
11606 break;
11607
11608 case pvm_specialized_instruction_opcode_swapgtlu:
11609 break;
11610
11611 case pvm_specialized_instruction_opcode_sync:
11612 break;
11613
11614 case pvm_specialized_instruction_opcode_time:
11615 break;
11616
11617 case pvm_specialized_instruction_opcode_tor:
11618 break;
11619
11620 case pvm_specialized_instruction_opcode_tuck:
11621 break;
11622
11623 case pvm_specialized_instruction_opcode_tyagetb:
11624 break;
11625
11626 case pvm_specialized_instruction_opcode_tyagett:
11627 break;
11628
11629 case pvm_specialized_instruction_opcode_tyisc:
11630 break;
11631
11632 case pvm_specialized_instruction_opcode_tyissct:
11633 break;
11634
11635 case pvm_specialized_instruction_opcode_typof:
11636 break;
11637
11638 case pvm_specialized_instruction_opcode_tysctn:
11639 break;
11640
11641 case pvm_specialized_instruction_opcode_unmap:
11642 break;
11643
11644 case pvm_specialized_instruction_opcode_unreachable:
11645 break;
11646
11647 case pvm_specialized_instruction_opcode_ureloc:
11648 break;
11649
11650 case pvm_specialized_instruction_opcode_write__retR:
11651 /* Caller instruction: make place for the return address,
11652 whose correct value will be patched in at specialization time. */
11653 jitter_add_specialized_instruction_literal (p, -1);
11654 break;
11655
11656 case pvm_specialized_instruction_opcode__Aba__fR_A_mno_mfast_mbranches:
11657 /* Non-relocatable instruction: make place for the return label,
11658 whose correct value will be patched in at specialization time. */
11659 jitter_add_specialized_instruction_literal (p, -1);
11660 break;
11661
11662 case pvm_specialized_instruction_opcode__Abn__fR_A_mno_mfast_mbranches:
11663 /* Non-relocatable instruction: make place for the return label,
11664 whose correct value will be patched in at specialization time. */
11665 jitter_add_specialized_instruction_literal (p, -1);
11666 break;
11667
11668 case pvm_specialized_instruction_opcode__Abnn__fR_A_mno_mfast_mbranches:
11669 /* Non-relocatable instruction: make place for the return label,
11670 whose correct value will be patched in at specialization time. */
11671 jitter_add_specialized_instruction_literal (p, -1);
11672 break;
11673
11674 case pvm_specialized_instruction_opcode__Abnzi__fR_A_mno_mfast_mbranches:
11675 /* Non-relocatable instruction: make place for the return label,
11676 whose correct value will be patched in at specialization time. */
11677 jitter_add_specialized_instruction_literal (p, -1);
11678 break;
11679
11680 case pvm_specialized_instruction_opcode__Abnziu__fR_A_mno_mfast_mbranches:
11681 /* Non-relocatable instruction: make place for the return label,
11682 whose correct value will be patched in at specialization time. */
11683 jitter_add_specialized_instruction_literal (p, -1);
11684 break;
11685
11686 case pvm_specialized_instruction_opcode__Abnzl__fR_A_mno_mfast_mbranches:
11687 /* Non-relocatable instruction: make place for the return label,
11688 whose correct value will be patched in at specialization time. */
11689 jitter_add_specialized_instruction_literal (p, -1);
11690 break;
11691
11692 case pvm_specialized_instruction_opcode__Abnzlu__fR_A_mno_mfast_mbranches:
11693 /* Non-relocatable instruction: make place for the return label,
11694 whose correct value will be patched in at specialization time. */
11695 jitter_add_specialized_instruction_literal (p, -1);
11696 break;
11697
11698 case pvm_specialized_instruction_opcode__Abzi__fR_A_mno_mfast_mbranches:
11699 /* Non-relocatable instruction: make place for the return label,
11700 whose correct value will be patched in at specialization time. */
11701 jitter_add_specialized_instruction_literal (p, -1);
11702 break;
11703
11704 case pvm_specialized_instruction_opcode__Abziu__fR_A_mno_mfast_mbranches:
11705 /* Non-relocatable instruction: make place for the return label,
11706 whose correct value will be patched in at specialization time. */
11707 jitter_add_specialized_instruction_literal (p, -1);
11708 break;
11709
11710 case pvm_specialized_instruction_opcode__Abzl__fR_A_mno_mfast_mbranches:
11711 /* Non-relocatable instruction: make place for the return label,
11712 whose correct value will be patched in at specialization time. */
11713 jitter_add_specialized_instruction_literal (p, -1);
11714 break;
11715
11716 case pvm_specialized_instruction_opcode__Abzlu__fR_A_mno_mfast_mbranches:
11717 /* Non-relocatable instruction: make place for the return label,
11718 whose correct value will be patched in at specialization time. */
11719 jitter_add_specialized_instruction_literal (p, -1);
11720 break;
11721
11722 default:
11723 jitter_fatal ("invalid specialized instruction opcode %i", (int)opcode);
11724 }
11725 return 1; // FIXME: I should rethink this return value.
11726 }
11727
11728 void
pvm_state_initialize(struct pvm_state * jitter_state)11729 pvm_state_initialize (struct pvm_state *jitter_state)
11730 {
11731 struct pvm_state_backing * const jitter_state_backing
11732 __attribute__ ((unused))
11733 = & jitter_state->pvm_state_backing;
11734 struct pvm_state_runtime * const jitter_state_runtime
11735 __attribute__ ((unused))
11736 = & jitter_state->pvm_state_runtime;
11737
11738 /* Initialize the Array. */
11739 jitter_state_backing->jitter_slow_register_no_per_class = 0; // FIXME: raise?
11740 jitter_state_backing->jitter_array
11741 = jitter_xmalloc (PVM_ARRAY_SIZE(jitter_state_backing
11742 ->jitter_slow_register_no_per_class));
11743
11744 /* Initialize special-purpose data. */
11745 pvm_initialize_special_purpose_data (PVM_ARRAY_TO_SPECIAL_PURPOSE_STATE_DATA (jitter_state_backing->jitter_array));
11746
11747 /* Initialize stack backings and stack runtime data structures, pointing
11748 to memory from the backings. */
11749 jitter_stack_initialize_tos_backing(& jitter_state_backing->jitter_stack_stack_backing,
11750 sizeof (pvm_val),
11751 65536,
11752 NULL,
11753 1,
11754 1);
11755 JITTER_STACK_TOS_INITIALIZE(pvm_val, jitter_state_runtime-> ,
11756 stack, jitter_state_backing->jitter_stack_stack_backing);
11757 jitter_stack_initialize_ntos_backing(& jitter_state_backing->jitter_stack_returnstack_backing,
11758 sizeof (pvm_val),
11759 65536,
11760 NULL,
11761 1,
11762 1);
11763 JITTER_STACK_NTOS_INITIALIZE(pvm_val, jitter_state_runtime-> ,
11764 returnstack, jitter_state_backing->jitter_stack_returnstack_backing);
11765 jitter_stack_initialize_ntos_backing(& jitter_state_backing->jitter_stack_exceptionstack_backing,
11766 sizeof (struct pvm_exception_handler),
11767 65536,
11768 NULL,
11769 1,
11770 1);
11771 JITTER_STACK_NTOS_INITIALIZE(struct pvm_exception_handler, jitter_state_runtime-> ,
11772 exceptionstack, jitter_state_backing->jitter_stack_exceptionstack_backing);
11773
11774 /* Initialise the link register, if present. */
11775 #if defined(JITTER_DISPATCH_SWITCH) \
11776 || defined(JITTER_DISPATCH_DIRECT_THREADING) \
11777 || defined(JITTER_DISPATCH_MINIMAL_THREADING) \
11778 || ( defined(JITTER_DISPATCH_NO_THREADING) \
11779 && ! defined(JITTER_MACHINE_SUPPORTS_PROCEDURE))
11780 jitter_state_runtime->_jitter_link = NULL;
11781 #endif
11782
11783 /* No need to initialise r-class fast registers. */
11784
11785
11786 /* User code for state initialization. */
11787 #line 836 "../../libpoke/pvm.jitter"
11788 #line 836 "../../libpoke/pvm.jitter"
11789
11790 jitter_state_backing->vm = NULL;
11791 jitter_state_backing->canary = NULL;
11792 jitter_state_backing->exit_code = PVM_EXIT_OK;
11793 jitter_state_backing->result_value = PVM_NULL;
11794 jitter_state_runtime->endian = IOS_ENDIAN_MSB;
11795 jitter_state_runtime->nenc = IOS_NENC_2;
11796 jitter_state_runtime->pretty_print = 0;
11797 jitter_state_runtime->omode = PVM_PRINT_FLAT;
11798 jitter_state_runtime->obase = 10;
11799 jitter_state_runtime->omaps = 0;
11800 jitter_state_runtime->odepth = 0;
11801 jitter_state_runtime->oindent = 2;
11802 jitter_state_runtime->oacutoff = 0;
11803
11804 /* End of the user code for state initialization. */
11805
11806 /* Link this new state to the list of states. */
11807 JITTER_LIST_LINK_LAST (pvm_state, links, & pvm_vm->states, jitter_state);
11808
11809 }
11810
11811 void
pvm_state_finalize(struct pvm_state * jitter_state)11812 pvm_state_finalize (struct pvm_state *jitter_state)
11813 {
11814 /* Unlink this new state from the list of states. */
11815 JITTER_LIST_UNLINK (pvm_state, links, & pvm_vm->states, jitter_state);
11816
11817 struct pvm_state_backing * const jitter_state_backing
11818 __attribute__ ((unused))
11819 = & jitter_state->pvm_state_backing;
11820 struct pvm_state_runtime * const jitter_state_runtime
11821 __attribute__ ((unused))
11822 = & jitter_state->pvm_state_runtime;
11823
11824 /* Finalize special-purpose data. */
11825 pvm_finalize_special_purpose_data (PVM_ARRAY_TO_SPECIAL_PURPOSE_STATE_DATA (jitter_state_backing->jitter_array));
11826
11827 /* Finalize stack backings -- There is no need to finalize the stack
11828 runtime data structures, as they hold no heap data of their own. */
11829 jitter_stack_finalize_backing (& jitter_state_backing->jitter_stack_stack_backing);
11830 jitter_stack_finalize_backing (& jitter_state_backing->jitter_stack_returnstack_backing);
11831 jitter_stack_finalize_backing (& jitter_state_backing->jitter_stack_exceptionstack_backing);
11832
11833
11834 /* User code for state finalization. */
11835 #line 854 "../../libpoke/pvm.jitter"
11836 #line 854 "../../libpoke/pvm.jitter"
11837
11838 /* Finalize extra state here. */
11839
11840 /* End of the user code for state finalization. */
11841
11842 /* Finalize the Array. */
11843 free ((void *) jitter_state_backing->jitter_array);
11844
11845 }
11846
11847